<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html dir="ltr" xmlns="http://www.w3.org/1999/xhtml" typeof="bibo:Document">
<head>
<title>JSON-LD API 1.0</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<!--
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
  -->



<style type="text/css">
.diff { font-weight:bold; color:#0a3; }
</style>
<style>/*****************************************************************
 * ReSpec 3 CSS
 * Robin Berjon - http://berjon.com/
 *****************************************************************/

/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  1px solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  1px dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

cite .bibref {
    font-style: normal;
}

code {
    color:  #ff4500;
}


/* --- --- */
ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }

/* --- TOC --- */
.toc a, .tof a {
    text-decoration:    none;
}

a .secno, a .figno {
    color:  #000;
}

ul.tof, ol.tof {
    list-style: none outside none;
}

.caption {
    margin-top: 0.5em;
    font-style:   italic;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}
</style><style>/* --- EXAMPLES --- */
div.example-title {
    min-width: 7.5em;
    color: #b9ab2d;
}
div.example-title span {
    text-transform: uppercase;   
}
aside.example, div.example, div.illegal-example {
    padding: 0.5em;
    margin: 1em 0;
    position: relative;
    clear: both;
}
div.illegal-example { color: red }
div.illegal-example p { color: black }
aside.example, div.example {
    padding: .5em;
    border-left-width: .5em;
    border-left-style: solid;
    border-color: #e0cb52;
    background: #fcfaee;    
}

aside.example div.example {
    border-left-width: .1em;
    border-color: #999;
    background: #fff;
}
aside.example div.example div.example-title {
    color: #999;
}
</style><style>/* --- ISSUES/NOTES --- */
div.issue-title, div.note-title {
    padding-right:  1em;
    min-width: 7.5em;
    color: #b9ab2d;
}
div.issue-title { color: #e05252; }
div.note-title { color: #52e052; }
div.issue-title span, div.note-title span {
    text-transform: uppercase;
}
div.note, div.issue {
    margin-top: 1em;
    margin-bottom: 1em;
}
.note > p:first-child, .issue > p:first-child { margin-top: 0 }
.issue, .note {
    padding: .5em;
    border-left-width: .5em;
    border-left-style: solid;
}
div.issue, div.note {
    padding: 0.5em;
    margin: 1em 0;
    position: relative;
    clear: both;
}
span.note, span.issue { padding: .1em .5em .15em; }

.issue {
    border-color: #e05252;
    background: #fbe9e9;
}
.note {
    border-color: #52e052;
    background: #e9fbe9;
}


</style><style>/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID, .idlDictionaryID, .idlCallbackID, .idlEnumID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType, .idlMemberType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName, .idlMemberName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a, .idlMemberName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType, .idlCallbackType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields, dl.dictionary-members {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt, .dictionary-members dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code, .dictionary-members dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code, .dictionary-members dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code, .dictionary-members dt .idlMemberType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd, .dictionary-members dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}
</style><link rel="stylesheet" href="http://www.w3.org/StyleSheets/TR/W3C-ED" /><script>window["_GOOG_TRANS_EXT_VER"] = "1";</script>
<!--[if lt IE 9]><script src='undefined://www.w3.org/2008/site/js/html5shiv.js'></script><![endif]-->
</head>

<body><div class="head">
  <p>
    
      <a href="http://www.w3.org/"><img width="72" height="48" src="http://www.w3.org/Icons/w3c_home" alt="W3C" /></a>
    
  </p>
  <h1 class="title" id="title">JSON-LD API 1.0</h1>
  
    <h2 id="subtitle">An Application Programming Interface for the JSON-LD Syntax</h2>
  
  <h2 id="w3c-editor-s-draft-30-september-2012"><abbr title="World Wide Web Consortium">W3C</abbr> Editor's Draft 30 September 2012</h2>
  <dl>
    
      <dt>This version:</dt>
      <dd><a href="http://dvcs.w3.org/hg/json-ld/raw-file/default/spec/latest/json-ld-api/index.html">http://dvcs.w3.org/hg/json-ld/raw-file/default/spec/latest/json-ld-api/index.html</a></dd>
      <dt>Latest published version:</dt>
      <dd><a href="http://www.w3.org/TR/json-ld-api/">http://www.w3.org/TR/json-ld-api/</a></dd>
    
    
      <dt>Latest editor's draft:</dt>
      <dd><a href="http://dvcs.w3.org/hg/json-ld/raw-file/default/spec/latest/json-ld-api/index.html">http://dvcs.w3.org/hg/json-ld/raw-file/default/spec/latest/json-ld-api/index.html</a></dd>
    
    
    
    
      
    
    
    
    <dt>Editors:</dt>
    <dd rel="bibo:editor" inlist=""><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Manu Sporny" href="http://manu.sporny.org/">Manu Sporny</a>, <a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">Digital Bazaar</a></span>
</dd>
<dd rel="bibo:editor" inlist=""><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Gregg Kellogg" href="http://greggkellogg.net/">Gregg Kellogg</a>, <a rel="foaf:workplaceHomepage" href="http://kellogg-assoc.com/">Kellogg Associates</a></span>
</dd>
<dd rel="bibo:editor" inlist=""><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Markus Lanthaler" href="http://www.markus-lanthaler.com/">Markus Lanthaler</a>, <a rel="foaf:workplaceHomepage" href="http://www.tugraz.at/">Graz University of Technology</a></span>
</dd>

    
      <dt>Authors:</dt>
      <dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Dave Longley" href="http://digitalbazaar.com/">Dave Longley</a>, <a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">Digital Bazaar</a></span>
</dd>
<dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Manu Sporny" href="http://digitalbazaar.com/">Manu Sporny</a>, <a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">Digital Bazaar</a></span>
</dd>
<dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Gregg Kellogg" href="http://greggkellogg.net/">Gregg Kellogg</a>, <a rel="foaf:workplaceHomepage" href="http://kellogg-assoc.com/">Kellogg Associates</a></span>
</dd>
<dd rel="dcterms:contributor"><span typeof="foaf:Person"><a rel="foaf:homepage" property="foaf:name" content="Markus Lanthaler" href="http://www.markus-lanthaler.com/">Markus Lanthaler</a>, <a rel="foaf:workplaceHomepage" href="http://www.tugraz.at/">Graz University of Technology</a></span>
</dd>

    
  </dl>
  
  
    <p>
      
        This document is also available in this non-normative format: 
      
      <a href="diff-20120712.html">diff to previous version</a>
    </p>
  
  
  
    
      <p class="copyright">
        <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © 
        2010-2012
        
        <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> 
        (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>,
        <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>,
        <a href="http://www.keio.ac.jp/">Keio</a>), All Rights Reserved.
        <abbr title="World Wide Web Consortium">W3C</abbr> <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>,
        <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and
        <a href="http://www.w3.org/Consortium/Legal/copyright-documents">document use</a> rules apply.
      </p>
    
  
  <hr />
</div>
<section id="abstract" class="introductory"><h2>Abstract</h2>
<p>
JSON [<cite><a class="bibref" href="#bib-RFC4627">RFC4627</a></cite>] has proven to be a highly useful object serialization and
messaging format. JSON-LD [<cite><a class="bibref" href="#bib-JSON-LD">JSON-LD</a></cite>] harmonizes the representation of
Linked Data in JSON by outlining a common JSON representation format for
expressing directed graphs; mixing both Linked Data and non-Linked Data in
a single document. This document outlines an Application Programming
Interface and a set of algorithms for programmatically transforming
JSON-LD documents in order to make them easier to work with in programming
environments like JavaScript, Python, and Ruby.
</p>
</section><section id="sotd" class="introductory"><h2>Status of This Document</h2>
  
    
      
        <p>
          <em>This section describes the status of this document at the time of its publication. Other
          documents may supersede this document. A list of current <abbr title="World Wide Web Consortium">W3C</abbr> publications and the latest revision
          of this technical report can be found in the <a href="http://www.w3.org/TR/"><abbr title="World Wide Web Consortium">W3C</abbr> technical reports
          index</a> at http://www.w3.org/TR/.</em>
        </p>
        
<p>This document has been under development for over 18 months in the
JSON for Linking Data Community Group. The document has recently been
transferred to the RDF Working Group for review, improvement, and publication
along the Recommendation track. The specification has undergone significant
development, review, and changes during the course of the last 18 months.
</p>
<p>
There are currently
<a href="http://json-ld.org/#impl">five interoperable implementations</a>
of this specification. There is
a <a href="https://github.com/json-ld/json-ld.org/tree/main/test-suite">fairly complete test suite</a>
and a
<a href="http://json-ld.org/playground/">live JSON-LD editor</a>
that is capable of demonstrating the features described in
this document. While development on implementations, the test suite
and the live editor will continue, they are believed to be mature enough
to be integrated into a non-production system at this point in time with
the expectation that they could be used in a production system within the
next year.
</p>
<div class="issue"><div class="issue-title"><span>Issue</span></div><p class="">
It is important for readers to understand that the scope of this document is
currently under debate and new features may be added to the specification.
Existing features may be modified heavily or removed entirely from the
specification upon further review and feedback from the broader community.
This is a work in progress and publication as a Working Draft
does not require that all Working Group members agree on the content of the
document.
</p></div>

<p>There are a number of ways that one may participate in the development of
  this specification:</p>

<ul>
  <li>If you want to make sure that your feedback is formally addressed by
    the RDF Working Group, you should send it to public-rdf-comments:
    <a href="http://lists.w3.org/Archives/Public/public-rdf-comments/">public-rdf-comments@w3.org</a></li>

  <li>Ad-hoc technical discussion primarily occurs on the public community mailing list:
    <a href="http://lists.w3.org/Archives/Public/public-linked-json/">public-linked-json@w3.org</a></li>

  <li><a href="http://json-ld.org/minutes/">Public JSON-LD Community Group teleconferences</a>
  are held on Tuesdays at 1500UTC every week. Participation is open to the
  public.</li>

  <li>RDF Working Group teleconferences are held on Wednesdays at 1500UTC
  every week. Participation is limited to RDF Working Group members.</li>

  <li>Specification bugs and issues should be reported in the
    <a href="https://github.com/json-ld/json-ld.org/issues">issue tracker</a>
    if you do not want to send an e-mail to the public-rdf-comments mailing
    list.</li>

  <li><a href="https://github.com/json-ld/json-ld.org/tree/main/spec">Source code</a>
    for the specification can be found on Github.</li>

  <li>The <a href="http://webchat.freenode.net/?channels=json-ld">#json-ld</a>
    IRC channel is available for real-time discussion on irc.freenode.net.</li>
</ul>


        <p>
          This document was published by the <a href="http://www.w3.org/2011/rdf-wg/">RDF Working Group</a> as an Editor's Draft.
          
          If you wish to make comments regarding this document, please send them to 
          <a href="mailto:public-rdf-comments@w3.org">public-rdf-comments@w3.org</a> 
          (<a href="mailto:public-rdf-comments-request@w3.org?subject=subscribe">subscribe</a>,
          <a href="http://lists.w3.org/Archives/Public/public-rdf-comments/">archives</a>).
          
          
          All feedback is welcome.
        </p>
        
          <p>
            Publication as an Editor's Draft does not imply endorsement by the <abbr title="World Wide Web Consortium">W3C</abbr> Membership.
            This is a draft document and may be updated, replaced or obsoleted by other documents at 
            any time. It is inappropriate to cite this document as other than work in progress.
          </p>
        
        
        <p>
          
            This document was produced by a group operating under the 
            <a href="http://www.w3.org/Consortium/Patent-Policy-20040205/">5 February 2004 <abbr title="World Wide Web Consortium">W3C</abbr> Patent Policy</a>.
          
          
          
            
              <abbr title="World Wide Web Consortium">W3C</abbr> maintains a <a href="http://www.w3.org/2004/01/pp-impl/46168/status" rel="disclosure">public list of any patent disclosures</a> 
            
            made in connection with the deliverables of the group; that page also includes instructions for 
            disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains
            <a href="http://www.w3.org/Consortium/Patent-Policy-20040205/#def-essential">Essential Claim(s)</a> must disclose the
            information in accordance with <a href="http://www.w3.org/Consortium/Patent-Policy-20040205/#sec-Disclosure">section
            6 of the <abbr title="World Wide Web Consortium">W3C</abbr> Patent Policy</a>.
          
          
        </p>
        
      
    
  
</section><section id="toc"><h2 class="introductory">Table of Contents</h2><ul class="toc"><li class="tocline"><a href="#introduction" class="tocxref"><span class="secno">1. </span>Introduction</a></li><li class="tocline"><a href="#features" class="tocxref"><span class="secno">2. </span>Features</a><ul class="toc"><li class="tocline"><a href="#expansion" class="tocxref"><span class="secno">2.1 </span>Expansion</a></li><li class="tocline"><a href="#compaction" class="tocxref"><span class="secno">2.2 </span>Compaction</a></li><li class="tocline"><a href="#rdf-conversion" class="tocxref"><span class="secno">2.3 </span>RDF Conversion</a></li></ul></li><li class="tocline"><a href="#the-application-programming-interface" class="tocxref"><span class="secno">3. </span>The Application Programming Interface</a><ul class="toc"><li class="tocline"><a href="#general-terminology" class="tocxref"><span class="secno">3.1 </span>General Terminology</a></li><li class="tocline"><a href="#jsonldprocessor" class="tocxref"><span class="secno">3.2 </span>JsonLdProcessor</a><ul class="toc"><li class="tocline"><a href="#methods" class="tocxref"><span class="secno">3.2.1 </span>Methods</a></li></ul></li><li class="tocline"><a href="#callbacks" class="tocxref"><span class="secno">3.3 </span>Callbacks</a><ul class="toc"><li class="tocline"><a href="#jsonldprocessingerror" class="tocxref"><span class="secno">3.3.1 </span>JsonLdProcessingError</a></li><li class="tocline"><a href="#jsonldcallback" class="tocxref"><span class="secno">3.3.2 </span>JsonLdCallback</a></li><li class="tocline"><a href="#quadcallback" class="tocxref"><span class="secno">3.3.3 </span>QuadCallback</a></li><li class="tocline"><a href="#conformancecallback" class="tocxref"><span class="secno">3.3.4 </span>ConformanceCallback</a></li></ul></li><li class="tocline"><a href="#data-structures" class="tocxref"><span class="secno">3.4 </span>Data Structures</a><ul class="toc"><li class="tocline"><a href="#iri" class="tocxref"><span class="secno">3.4.1 </span><abbr title="Internationalized Resource Identifier">IRI</abbr></a></li><li class="tocline"><a href="#jsonldoptions" class="tocxref"><span class="secno">3.4.2 </span>JsonLdOptions</a></li><li class="tocline"><a href="#quad" class="tocxref"><span class="secno">3.4.3 </span>Quad</a></li><li class="tocline"><a href="#node" class="tocxref"><span class="secno">3.4.4 </span>Node</a></li><li class="tocline"><a href="#iri-1" class="tocxref"><span class="secno">3.4.5 </span><abbr title="Internationalized Resource Identifier">IRI</abbr></a></li><li class="tocline"><a href="#blank-node" class="tocxref"><span class="secno">3.4.6 </span>Blank Node</a></li><li class="tocline"><a href="#literal" class="tocxref"><span class="secno">3.4.7 </span>Literal</a></li></ul></li></ul></li><li class="tocline"><a href="#algorithms" class="tocxref"><span class="secno">4. </span>Algorithms</a><ul class="toc"><li class="tocline"><a href="#algorithm-terms" class="tocxref"><span class="secno">4.1 </span>Algorithm Terms</a></li><li class="tocline"><a href="#context-processing" class="tocxref"><span class="secno">4.2 </span>Context Processing</a></li><li class="tocline"><a href="#iri-expansion" class="tocxref"><span class="secno">4.3 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a></li><li class="tocline"><a href="#iri-compaction" class="tocxref"><span class="secno">4.4 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a><ul class="toc"><li class="tocline"><a href="#iri-compaction-algorithm" class="tocxref"><span class="secno">4.4.1 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction Algorithm</a></li><li class="tocline"><a href="#term-rank-algorithm" class="tocxref"><span class="secno">4.4.2 </span>Term Rank Algorithm</a></li></ul></li><li class="tocline"><a href="#value-expansion" class="tocxref"><span class="secno">4.5 </span>Value Expansion</a></li><li class="tocline"><a href="#value-compaction" class="tocxref"><span class="secno">4.6 </span>Value Compaction</a></li><li class="tocline"><a href="#expansion-1" class="tocxref"><span class="secno">4.7 </span>Expansion</a><ul class="toc"><li class="tocline"><a href="#expansion-algorithm" class="tocxref"><span class="secno">4.7.1 </span>Expansion Algorithm</a></li></ul></li><li class="tocline"><a href="#compaction-1" class="tocxref"><span class="secno">4.8 </span>Compaction</a><ul class="toc"><li class="tocline"><a href="#compaction-algorithm" class="tocxref"><span class="secno">4.8.1 </span>Compaction Algorithm</a></li></ul></li><li class="tocline"><a href="#flattening" class="tocxref"><span class="secno">4.9 </span>Flattening</a><ul class="toc"><li class="tocline"><a href="#flattening-algorithm" class="tocxref"><span class="secno">4.9.1 </span>Flattening Algorithm</a></li><li class="tocline"><a href="#node-map-generation" class="tocxref"><span class="secno">4.9.2 </span>Node Map Generation</a></li><li class="tocline"><a href="#generate-blank-node-identifier" class="tocxref"><span class="secno">4.9.3 </span>Generate Blank Node Identifier</a></li></ul></li><li class="tocline"><a href="#rdf-conversion-1" class="tocxref"><span class="secno">4.10 </span>RDF Conversion</a><ul class="toc"><li class="tocline"><a href="#overview" class="tocxref"><span class="secno">4.10.1 </span>Overview</a></li><li class="tocline"><a href="#parsing-examples" class="tocxref"><span class="secno">4.10.2 </span>Parsing Examples</a></li><li class="tocline"><a href="#convert-to-rdf-algorithm" class="tocxref"><span class="secno">4.10.3 </span>Convert to RDF Algorithm</a></li><li class="tocline"><a href="#list-conversion" class="tocxref"><span class="secno">4.10.4 </span>List Conversion</a></li><li class="tocline"><a href="#convert-from-rdf-algorithm" class="tocxref"><span class="secno">4.10.5 </span>Convert from RDF Algorithm</a></li></ul></li></ul></li><li class="tocline"><a href="#data-round-tripping" class="tocxref"><span class="secno">5. </span>Data Round Tripping</a></li><li class="tocline"><a href="#acknowledgements" class="tocxref"><span class="secno">A. </span>Acknowledgements</a></li><li class="tocline"><a href="#references" class="tocxref"><span class="secno">B. </span>References</a><ul class="toc"><li class="tocline"><a href="#normative-references" class="tocxref"><span class="secno">B.1 </span>Normative references</a></li><li class="tocline"><a href="#informative-references" class="tocxref"><span class="secno">B.2 </span>Informative references</a></li></ul></li></ul></section>



<section id="introduction">

<!--OddPage-->
<h2><span class="secno">1. </span>Introduction</h2>

<p>
This document is a detailed specification for an Application Programming
Interface for the JSON-LD Syntax. The document is primarily intended for
the following audiences:
</p>

<ul>
  <li>Web authors and developers that want a very detailed view of how
  a JSON-LD processor and the API operates.</li>
  <li>Software developers that want to implement processors and APIs for
  JSON-LD.</li>
</ul>

<p>
To understand the basics in this specification you must first be familiar with
JSON, which is detailed in [<cite><a class="bibref" href="#bib-RFC4627">RFC4627</a></cite>]. You must also understand the
JSON-LD Syntax [<cite><a class="bibref" href="#bib-JSON-LD">JSON-LD</a></cite>], which is the base syntax used by all of the
algorithms in this document. To understand the API and how it is
intended to operate in a programming environment, it is useful to have working
knowledge of the JavaScript programming language [<cite><a class="bibref" href="#bib-ECMA-262">ECMA-262</a></cite>] and
WebIDL [<cite><a class="bibref" href="#bib-WEBIDL">WEBIDL</a></cite>]. To understand how JSON-LD maps to RDF, it is helpful to be
familiar with the basic RDF concepts [<cite><a class="bibref" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>].</p>

</section>

<section id="features">

<!--OddPage-->
<h2><span class="secno">2. </span>Features</h2>

<p>
The JSON-LD Syntax specification [<cite><a class="bibref" href="#bib-JSON-LD">JSON-LD</a></cite>] outlines a language that may be
used to express Linked Data in JSON. Often, it is useful to be able to
transform JSON-LD documents so that they may be easily processed in
a programming environment like JavaScript, Python or Ruby.
</p>

<p>
There are four major types of transformation that are discussed in this
document; compaction, expansion, and RDF conversion.
</p>

<section id="expansion">
  <h3><span class="secno">2.1 </span>Expansion</h3>
  <p>
Software algorithms are easiest to write when the data that they are processing
have a regular form. Since information can be represented by JSON-LD in a
variety of different ways, transforming all of these methods into a uniform
structure allows the developer to simplify their processing code. For example,
note that the following input uses only <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s and is fairly
compact:
  </p>

  <div class="example"><div class="example-title"><span>Example 1</span></div><pre class="example">var input1 = {
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre></div>

  <p>
The next input example uses one <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> to express a property, but
leaves the rest of the information untouched.
  </p>

  <div class="example"><div class="example-title"><span>Example 2</span></div><pre class="example">var input2 = {
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;
  &quot;<span class="diff">http://xmlns.com/foaf/0.1/name</span>&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre></div>

  <p>
While both inputs are valid JSON-LD, writing a program to handle every
permutation of possible inputs can be difficult, especially when the incoming
context could change as well. To ensure that the data can be given a more
uniform structure, JSON-LD introduces the notion of expansion.
<dfn title="expansion" id="dfn-expansion">Expansion</dfn> performs two important operations. The first is to
expand all values that are <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>s to their fully expanded form.
The second is to express all values in <dfn title="expanded_form" id="dfn-expanded_form">expanded form</dfn>. To
transform both inputs above to the same representation, the developer could
do the following:
  </p>

  <div class="example"><div class="example-title"><span>Example 3</span></div><pre class="example">function expansionCallback(output) {
   console.log(output);
}

// the second parameter is 'null' because the developer does not wish to
// inject another context value
jsonld.expand(input1, null, expansionCallback);
jsonld.expand(input2, null, expansionCallback);</pre></div>

  <p>
The output for both calls above will be:
  </p>

  <div class="example"><div class="example-title"><span>Example 4</span></div><pre class="example">[{
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{
    &quot;@value&quot;: &quot;Manu Sporny&quot;
  }],
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: [{
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }]
}]</pre></div>

  <p>
Note that in the example above; all <a class="tref internalDFN" title="context" href="#dfn-context">context</a> definitions have
been removed, all <a class="tref internalDFN" title="term" href="#dfn-term">term</a> and prefixes have been expanded to full
IRIs, and all <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a>s are expressed in <a class="tref internalDFN" title="expanded_form" href="#dfn-expanded_form">expanded form</a>.
While the output is more difficult for a human to read, it is easier for a
software program to process because of its very regular structure.
  </p>
</section>

<section id="compaction">
  <h3><span class="secno">2.2 </span>Compaction</h3>
  <p>
While expansion expands a given input as much as possible, compaction performs
the opposite operation - expressing a given input as succinctly as possible.
While expansion is meant to produce something that is easy to process by
software programs, compaction is meant to produce something that is easy to
read by software developers. Compaction uses a developer-supplied
<a class="tref internalDFN" title="context" href="#dfn-context">context</a> to compresses all <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>s to <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s
or <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>es, and compacts all <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a>s expressed
in <a class="tref internalDFN" title="expanded_form" href="#dfn-expanded_form">expanded form</a> as much as possible.
  </p>

  <p>
The following example expresses input that has already been fully expanded:
  </p>

  <div class="example"><div class="example-title"><span>Example 5</span></div><pre class="example">var expandedInput = [{
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{
    &quot;@value&quot;: &quot;Manu Sporny&quot;
  }],
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: [{
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }]
}]</pre></div>

  <p>
A developer that wants to transform the data above into a more human-readable
form, could do the following using the JSON-LD API:
  </p>

  <div class="example"><div class="example-title"><span>Example 6</span></div><pre class="example">function compactionCallback(output) {
   console.log(output);
}

jsonld.compact(expandedInput, &quot;http://json-ld.org/contexts/person.jsonld&quot;, compactionCallback);</pre></div>

  <p>
The following would be the result of the call above:
  </p>

  <div class="example"><div class="example-title"><span>Example 7</span></div><pre class="example">{
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre></div>

  <p>
Note that all of the <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s have been compressed and
the <a class="tref internalDFN" title="context" href="#dfn-context">context</a> has been injected into the output. While compacted
output is most useful to humans, it can also be carefully used to generate
structures that are easy to use for developers to program against as well.
  </p>

</section>

<section id="rdf-conversion">
  <h3><span class="secno">2.3 </span>RDF Conversion</h3>
  <p>
JSON-LD can be used to losslessly express the RDF data model as described in
the RDF Concepts document  [<cite><a class="bibref" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>]. This ensures that
data can be round-tripped from any RDF syntax, like N-Triples or TURTLE,
without any loss in the fidelity of the data. Assume the following RDF input
in N-Triples format:
  </p>

  <div class="example"><div class="example-title"><span>Example 8</span></div><pre class="example">var data = &quot;
&lt;http://manu.sporny.org/about/#manu&gt; &lt;http://xmlns.com/foaf/0.1/name&gt; \&quot;Manu Sporny\&quot; .\n
&lt;http://manu.sporny.org/about/#manu&gt; &lt;http://xmlns.com/foaf/0.1/homepage&gt; &lt;http://manu.sporny.org/&gt; .&quot;;</pre></div>

  <p>
A developer can use the JSON-LD API to transform the markup above into a
JSON-LD document:
  </p>

  <div class="example"><div class="example-title"><span>Example 9</span></div><pre class="example">function conversionCallback(result)
{
  console.log(&quot;JSON-LD Document: &quot;, result);
};

jsonld.fromRDF(data, conversionCallback, {&quot;format&quot;: &quot;ntriples&quot;});</pre></div>

  <p>
The following expanded output would be the result of the call above:
  </p>

  <div class="example"><div class="example-title"><span>Example 10</span></div><pre class="example">[{
  &quot;@id&quot;: &quot;http://manu.sporny.org/about/#manu&quot;,
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{
    &quot;@value&quot;: &quot;Manu Sporny&quot;
  }],
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: [{
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }]
}]</pre></div>

  <p>
Note that the output above, could easily be compacted to produce the following
using the technique outlined in the previous section:
  </p>

  <div class="example"><div class="example-title"><span>Example 11</span></div><pre class="example">{
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;,
  &quot;@id&quot;: &quot;http://manu.sporny.org/about/#manu&quot;,
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre></div>

  <p>
Transforming the node above back to RDF is as simple as calling the
<code>toRDF()</code> method:
  </p>

  <div class="example"><div class="example-title"><span>Example 12</span></div><pre class="example">var jsonldDocument = ...; // assign the JSON-LD document here

function rdfCallback(quads)
{
  console.log(&quot;RDF Data: &quot;, quads);
};

jsonld.toRDF(jsonldDocument, rdfCallback);</pre></div>

</section>

</section>

<section id="the-application-programming-interface">
  
<!--OddPage-->
<h2><span class="secno">3. </span>The Application Programming Interface</h2>

  <p>This API provides a clean mechanism that enables developers to convert
  JSON-LD data into a a variety of output formats that are easier to work
  with in various programming languages. If a JSON-LD API is provided in
  a programming environment, the entirety of the following API <em class="rfc2119" title="must">must</em> be
  implemented.
  </p>

<section id="general-terminology">
  <h3><span class="secno">3.1 </span>General Terminology</h3>

  <div class="issue"><div class="issue-title"><span>Issue</span></div><p class="">The intent of the Working Group and the Editors of this
    specification is to eventually align terminology used in this document
    with the terminology used in the RDF Concepts document to the extent to
    which it makes sense to do so. In general, if there is an analogue to
    terminology used in this document in the RDF Concepts document, the
    preference is to use the terminology in the RDF Concepts document.
  </p></div>

  <p>The following is an explanation of the general terminology used in this
    document:</p>

  <dl>
    <dt><dfn title="json_object" id="dfn-json_object">JSON object</dfn></dt>
    <dd>An object structure is represented as a pair of curly brackets surrounding zero or
      more name-value pairs. A name is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>. A single colon comes after
      each name, separating the name from the value. A single comma separates a value
      from a following name. The names within an object <em class="rfc2119" title="should">should</em> be unique.</dd>
    <dt><dfn title="array" id="dfn-array">array</dfn></dt>
    <dd>An array is represented as square brackets surrounding zero or more
      values that are separated by commas.</dd>
    <dt><dfn title="string" id="dfn-string">string</dfn></dt>
    <dd>A string is a sequence of zero or more Unicode (UTF-8) characters,
      wrapped in double quotes, using backslash escapes (if necessary). A
      character is represented as a single character string.</dd>
    <dt><dfn title="number" id="dfn-number">number</dfn></dt>
    <dd>A number is similar to that used in most programming languages, except
      that the octal and hexadecimal formats are not used and that leading
      zeros are not allowed.</dd>
    <dt><dfn title="true" id="dfn-true">true</dfn> and <dfn title="false" id="dfn-false">false</dfn></dt>
    <dd>Values that are used to express one of two possible boolean states.</dd>
    <dt><dfn title="null" id="dfn-null">null</dfn></dt>
    <dd>The use of the <a class="tref internalDFN" title="null" href="#dfn-null">null</a> value within JSON-LD is used to ignore or reset values.</dd>
    <dt><dfn title="keyword" id="dfn-keyword">keyword</dfn></dt>
    <dd>A JSON key that is specific to JSON-LD, specified in the JSON-LD Syntax specification [<cite><a class="bibref" href="#bib-JSON-LD">JSON-LD</a></cite>]
      in the section titled <cite><a href="../json-ld-syntax/#syntax-tokens-and-keywords">Syntax Tokens and Keywords</a></cite>.</dd>
    <dt><dfn title="context" id="dfn-context">context</dfn></dt>
    <dd>A a set of rules for interpreting a JSON-LD document as specified in
      <cite><a href="../json-ld-syntax/#the-context">The Context</a></cite> of the [<cite><a class="bibref" href="#bib-JSON-LD">JSON-LD</a></cite>] specification.</dd>
    <dt><dfn title="iri" id="dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></dfn></dt>
    <dd>An Internationalized Resource Identifier as described in [<cite><a class="bibref" href="#bib-RFC3987">RFC3987</a></cite>].</dd>
    <dt><dfn title="linked_data" id="dfn-linked_data">Linked Data</dfn></dt>
    <dd>A set of documents, each containing a representation of a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.</dd>
    <dt><dfn title="linked_data_graph" id="dfn-linked_data_graph">linked data graph</dfn></dt>
    <dd>An unordered labeled directed graph, where <a class="tref internalDFN" title="node" href="#dfn-node">nodes</a> are
      <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a> or <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">Blank Nodes</a>, or other values.
      A <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> is a generalized representation of a
      <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-rdf-graph">RDF graph</a></cite>
      as defined in [<cite><a class="bibref" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>].</dd>
    <dt><dfn title="named_graph" id="dfn-named_graph">named graph</dfn></dt>
    <dd>A <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> that is identified by an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</dd>
    <dt><dfn title="graph_name" id="dfn-graph_name">graph name</dfn></dt>
    <dd>The <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> identifying a <a class="tref internalDFN" title="named_graph" href="#dfn-named_graph">named graph</a>.</dd>
    <dt><dfn title="default_graph" id="dfn-default_graph">default graph</dfn></dt>
    <dd>When executing an algorithm, the graph where data should be placed
      if a <a class="tref internalDFN" title="named_graph" href="#dfn-named_graph">named graph</a> is not specified.</dd>
    <dt><dfn title="node" id="dfn-node">node</dfn></dt>
    <dd>A piece of information that is represented in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.</dd>
    <dt><dfn title="node_definition" id="dfn-node_definition">node definition</dfn></dt>
    <dd>A <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> used to represent a <a class="tref internalDFN" title="node" href="#dfn-node">node</a> and
      one or more properties of that node. A <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> is a
      node definition if it does not contain the keys <code>@value</code>,
      <code>@list</code> or <code>@set</code> and it has one or more keys
      other than <code>@id</code>.</dd>
    <dt><dfn title="node_reference" id="dfn-node_reference">node reference</dfn></dt>
    <dd>A <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> used to reference a node having only the
      <code>@id</code> key.</dd>
    <dt><dfn title="blank_node" id="dfn-blank_node">blank node</dfn></dt>
    <dd>A <a class="tref internalDFN" title="node" href="#dfn-node">node</a> in the <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> that does not contain a de-referenceable
      identifier because it is either ephemeral in nature or does not contain information that needs to be
      linked to from outside of the linked data graph. A blank node is assigned an identifier starting with
      the prefix <code>_:</code>.</dd>
    <dt><dfn title="property" id="dfn-property">property</dfn></dt>
    <dd>The <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> label of an edge in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.</dd>
    <dt><dfn title="subject" id="dfn-subject">subject</dfn></dt>
    <dd>A <a class="tref internalDFN" title="node" href="#dfn-node">node</a> in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> with at least one outgoing edge, related to an <a class="tref internalDFN" title="object" href="#dfn-object">object</a> node through a <a class="tref internalDFN" title="property" href="#dfn-property">property</a>.</dd>
    <dt><dfn title="object" id="dfn-object">object</dfn></dt>
    <dd>A <a class="tref internalDFN" title="node" href="#dfn-node">node</a> in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> with at least one incoming edge.</dd>
    <dt><dfn title="quad" id="dfn-quad">quad</dfn></dt>
    <dd>A piece of information that contains four items; a <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>, a <a class="tref internalDFN" title="property" href="#dfn-property">property</a>,
      an <a class="tref internalDFN" title="object" href="#dfn-object">object</a>, and a <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.</dd>
    <dt><dfn title="literal" id="dfn-literal">literal</dfn></dt>
    <dd>An <a class="tref internalDFN" title="object" href="#dfn-object">object</a> expressed as a value such as a string, number or in expanded form.</dd>
  </dl>
 </section>

  <section id="jsonldprocessor">
    <h3><span class="secno">3.2 </span>JsonLdProcessor</h3>

    <p>The JSON-LD processor interface is the high-level programming structure that developers
      use to access the JSON-LD transformation methods.</p>

    <div class="note"><div class="note-title"><span>Note</span></div><p class="">The JSON-LD API signatures are the same across all programming languages. Due
      to the fact that asynchronous programming is uncommon in certain languages, developers <em class="rfc2119" title="may">may</em>
      implement a processor with a synchronous interface instead. In that case, the <code>callback</code>
      parameter <em class="rfc2119" title="must not">must not</em> be included and the result <em class="rfc2119" title="must">must</em> be returned as a return value instead.</p></div>

    <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdProcessor">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">JsonLdProcessor</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-expand-void-object-or-object---or-IRI-input-object-or-IRI-context-JsonLdCallback-callback-JsonLdOptions-options">expand</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or IRI</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object or IRI</a>?</span> <span class="idlParamName">context</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a>?</span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-compact-void-object-or-object---or-IRI-input-object-or-IRI-context-JsonLdCallback-callback-JsonLdOptions-options">compact</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or IRI</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object or IRI</a></span> <span class="idlParamName">context</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a>?</span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-fromRDF-void-QuadArray-input-JsonLdCallback-callback-JsonLdOptions-options">fromRDF</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>[]</span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a>?</span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-toRDF-void-object-or-object---or-IRI-input-QuadCallback-callback-JsonLdOptions-options">toRDF</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or IRI</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-QuadCallback" class="idlType"><code>QuadCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a>?</span> <span class="idlParamName">options</span></span>);</span>
};</span></pre><section id="methods"><h4><span class="secno">3.2.1 </span>Methods</h4><dl class="methods"><dt id="widl-JsonLdProcessor-compact-void-object-or-object---or-IRI-input-object-or-IRI-context-JsonLdCallback-callback-JsonLdOptions-options"><code>compact</code></dt><dd>
        <a href="#compaction">Compacts</a> the given <code>input</code> using the
        <code>context</code> according to the steps in the
        <a href="#compaction-algorithm">Compaction Algorithm</a>. The
        <code>input</code> <em class="rfc2119" title="must">must</em> be copied, compacted and returned if there are
        no errors. If the compaction fails, an appropriate error <em class="rfc2119" title="must">must</em> be 
        returned via the callback.

        

        <dl title="InvalidContext">
          <dt>INVALID_SYNTAX</dt>
          <dd>A general syntax error was detected in the <code>@context</code>.
            For example, if a <code>@type</code> key maps to anything other than
            <code>@id</code> or an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, this error 
            would be returned via the <code>callback</code>.</dd>
          <dt>LOAD_ERROR</dt>
          <dd>There was a problem encountered loading a remote context.</dd>
        </dl>

        <dl title="ProcessingError">
          <dt>LOSSY_COMPACTION</dt>
          <dd>The compaction would lead to a loss of information, such as a
            <code>@language</code> value.</dd>
          <dt>CONFLICTING_DATATYPES</dt>
          <dd>The target datatype specified in the coercion rule and the
            datatype for the typed literal do not match.</dd>
          <dt>LIST_OF_LISTS_DETECTED</dt>
          <dd>A list of lists was detected. The list of lists feature is
            not supported in this version of JSON-LD due to the algorithmic
            complexity associated with conversion to RDF.</dd>
        </dl>
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or IRI</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to perform the compaction upon or an
            <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> referencing the JSON-LD document to compact.</td></tr><tr><td class="prmName">context</td><td class="prmType"><code><a>object or IRI</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The context to use when compacting the <code>input</code>; either in the
            form of an <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or as <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the expansion algorithm such as, e.g., the
            input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>. This also includes <code>optimize</code>,
            which if set will cause processor-specific optimization.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-expand-void-object-or-object---or-IRI-input-object-or-IRI-context-JsonLdCallback-callback-JsonLdOptions-options"><code>expand</code></dt><dd>
        <a href="#expansion">Expands</a> the given <code>input</code> according to
        the steps in the <a href="#expansion-algorithm">Expansion Algorithm</a>. The
        <code>input</code> <em class="rfc2119" title="must">must</em> be copied, expanded and returned if there are
        no errors. If the expansion fails, an appropriate error <em class="rfc2119" title="must">must</em> be 
        returned via the callback.

        

        <dl title="InvalidContext">
          <dt>INVALID_SYNTAX</dt>
          <dd>A general syntax error was detected in the <code>@context</code>.
            For example, if a <code>@type</code> key maps to anything other than
            <code>@id</code> or an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, this error type
            will be set in the error sent to the <code>callback</code>.</dd>
          <dt>LOAD_ERROR</dt>
          <dd>There was a problem encountered loading a remote context.</dd>
        </dl>

        <dl title="ProcessingError">
          <dt>LIST_OF_LISTS_DETECTED</dt>
          <dd>A list of lists was detected. The list of lists feature is
            not supported in this version of JSON-LD due to the algorithmic
            complexity associated with conversion to RDF.</dd>
        </dl>
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or IRI</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to perform the expansion upon or an
            <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> referencing the JSON-LD document to expand.</td></tr><tr><td class="prmName">context</td><td class="prmType"><code><a>object or IRI</a></code></td><td class="prmNullTrue">✔</td><td class="prmOptFalse">✘</td><td class="prmDesc">An optional external context to use additionally to the context embedded in
            <code>input</code> when expanding the <code>input</code>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the expansion algorithm such as, e.g., the
            input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-fromRDF-void-QuadArray-input-JsonLdCallback-callback-JsonLdOptions-options"><code>fromRDF</code></dt><dd>Creates a JSON-LD document given an set of <a class="datatype idlType" title="Quad" href="#idl-def-Quad"><code>Quads</code></a>.
        
      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>[]</code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A set of <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>s represented as an array of <a class="datatype idlType" title="Quad" href="#idl-def-Quad"><code>Quads</code></a>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when processing is complete on
            the given <code>input</code>.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that will affect the algorithm. This includes <code>notType</code>,
            which if set to <a class="tref internalDFN" title="true" href="#dfn-true">true</a> causes the resulting document to use <code>rdf:type</code>
            as a property, instead of <code>@type</code>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd><dt id="widl-JsonLdProcessor-toRDF-void-object-or-object---or-IRI-input-QuadCallback-callback-JsonLdOptions-options"><code>toRDF</code></dt><dd>
        Processes the <code>input</code> according to the
        <a href="#convert-to-rdf-algorithm">Convert to RDF Algorithm</a>, calling
        the provided <code>callback</code> for each <a class="datatype idlType" title="Quad" href="#idl-def-Quad"><code>Quad</code></a> generated.
        

        <dl title="InvalidContext">
          <dt>INVALID_SYNTAX</dt>
          <dd>A general syntax error was detected in the <code>@context</code>.
            For example, if a <code>@type</code> key maps to anything other than
            <code>@id</code> or an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, this error will
            be returned.</dd>
          <dt>LOAD_ERROR</dt>
          <dd>There was a problem encountered loading a remote context.</dd>
        </dl>

        <dl title="ProcessingError">
          <dt>LIST_OF_LISTS_DETECTED</dt>
          <dd>A list of lists was detected. This is not supported in this
            version of JSON-LD.</dd>
        </dl>

      <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object or object[] or IRI</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object or array of JSON-LD objects to convert to RDF or a <a href="#idl-def-IRI" class="idlType"><code>IRI</code></a>
            referencing the JSON-LD document to convert to RDF.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-QuadCallback" class="idlType"><code>QuadCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called when a <a class="datatype idlType" title="Quad" href="#idl-def-Quad"><code>Quad</code></a> is created from processing
            the given <code>input</code>.
          </td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A set of options that <em class="rfc2119" title="may">may</em> affect the conversion to RDF such as, e.g.,
            the input document's base <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></section>

  </section>

  <section id="callbacks">
    <h3><span class="secno">3.3 </span>Callbacks</h3>

    <div class="issue"><div class="issue-title"><a href="https://github.com/json-ld/json-ld.org/issues/153"><span>Issue 153</span></a></div><p class="">
    Developers should note that the details of error handling and 
    conformance handling are being actively debated.
    </p></div>
    
    <p>JSON-LD processors utilize a variety of callbacks in order to return
    information in an asynchronous manner to calling applications. This section
    details the parameters sent to those callbacks as well as the desired 
    operation of the callbacks.  
    </p>
    
    <section id="jsonldprocessingerror">
      <h4><span class="secno">3.3.1 </span>JsonLdProcessingError</h4>
      <p>The <a>JsonLdError</a> type is used to encapsulate a variety of
      parameters that outline the cause of a particular
      <a href="#idl-def-JsonLdProcessor" class="idlType"><code>JsonLdProcessor</code></a> error.</p>
      
      <pre class="idl"><span class="idlDictionary" id="idl-def-JsonLdProcessingError">dictionary <span class="idlDictionaryID">JsonLdProcessingError</span> {
<span class="idlMember">    <span class="idlMemberType"><a>string</a></span>                                 <span class="idlMemberName"><a href="#widl-JsonLdProcessingError-type">type</a></span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>string</a></span>                                 <span class="idlMemberName"><a href="#widl-JsonLdProcessingError-operation">operation</a></span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>object or object</a>[]</span>                     <span class="idlMemberName"><a href="#widl-JsonLdProcessingError-source">source</a></span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>string</a></span>                                 <span class="idlMemberName"><a href="#widl-JsonLdProcessingError-sourceKey">sourceKey</a></span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>object or object[] or string or number</a></span> <span class="idlMemberName"><a href="#widl-JsonLdProcessingError-sourceValue">sourceValue</a></span>;</span>
};</span></pre><section><h5 id="dictionary-jsonldprocessingerror-members">Dictionary <a class="idlType" href="#idl-def-JsonLdProcessingError"><code>JsonLdProcessingError</code></a> Members</h5><dl class="dictionary-members"><dt id="widl-JsonLdProcessingError-operation"><code>operation</code> of type <span class="idlMemberType"><a>string</a></span></dt><dd>a string representing the operation that was being performed
          when the conformance issue was raised. Valid values for the
          string include <code>compact</code>, <code>expand</code>, 
        <code>toRDF</code>, and <code>fromRDF</code>.</dd><dt id="widl-JsonLdProcessingError-source"><code>source</code> of type array of <span class="idlMemberType"><a>object or object</a></span></dt><dd>An object reference to the original JSON-LD document being 
          processed.</dd><dt id="widl-JsonLdProcessingError-sourceKey"><code>sourceKey</code> of type <span class="idlMemberType"><a>string</a></span></dt><dd>The key value associated with the value that triggered the
          conformance issue.</dd><dt id="widl-JsonLdProcessingError-sourceValue"><code>sourceValue</code> of type <span class="idlMemberType"><a>object or object[] or string or number</a></span></dt><dd>The value that triggered the conformance issue.</dd><dt id="widl-JsonLdProcessingError-type"><code>type</code> of type <span class="idlMemberType"><a>string</a></span></dt><dd>a string representing the particular error type, 
          such as <code>LIST_OF_LISTS_DETECTED</code>, as described in 
          the various algorithms in this document.</dd></dl></section>
    </section>
  
    <section id="jsonldcallback">
      <h4><span class="secno">3.3.2 </span>JsonLdCallback</h4>
      <p>The <a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a> is used to return a processed JSON-LD 
        representation as the result of processing an API method.</p>
  
      <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">JsonLdCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdCallback-processingComplete-void-JsonLdProcessingError-error-object-or-objectArray-document">processingComplete</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdProcessingError" class="idlType"><code>JsonLdProcessingError</code></a></span> <span class="idlParamName">error</span></span>, <span class="idlParam"><span class="idlParamType"><a>object or object</a>[]</span> <span class="idlParamName">document</span></span>);</span>
};</span></pre><section><h5 id="methods-1">Methods</h5><dl class="methods"><dt id="widl-JsonLdCallback-processingComplete-void-JsonLdProcessingError-error-object-or-objectArray-document"><code>processingComplete</code></dt><dd>This callback is invoked when processing is complete.
        
        <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">error</td><td class="prmType"><code><a href="#idl-def-JsonLdProcessingError" class="idlType"><code>JsonLdProcessingError</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">If the value is <code>null</code>, then no error occurred. If
             the value is non-<code>null</code>, a processing error occurred
             and the details will be contained within the <code>error</code>
             object.
           </td></tr><tr><td class="prmName">document</td><td class="prmType"><code><a>object or object</a>[]</code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The processed JSON-LD document.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></section>
    </section>
  
    <section id="quadcallback">
      <h4><span class="secno">3.3.3 </span>QuadCallback</h4>
      <p>The <a href="#idl-def-QuadCallback" class="idlType"><code>QuadCallback</code></a> is called whenever the processor generates a
      quad during processing.</p>
  
      <pre class="idl"><span class="idlInterface" id="idl-def-QuadCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">QuadCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-QuadCallback-quad-void-JsonLdProcessingError-error-Quad-quad">quad</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdProcessingError" class="idlType"><code>JsonLdProcessingError</code></a></span> <span class="idlParamName">error</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a></span> <span class="idlParamName">quad</span></span>);</span>
};</span></pre><section><h5 id="methods-2">Methods</h5><dl class="methods"><dt id="widl-QuadCallback-quad-void-JsonLdProcessingError-error-Quad-quad"><code>quad</code></dt><dd>This callback is invoked whenever a quad is generated by the processor.
        
        <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">error</td><td class="prmType"><code><a href="#idl-def-JsonLdProcessingError" class="idlType"><code>JsonLdProcessingError</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">If the value is <code>null</code>, then no error occurred. If
             the value is non-<code>null</code>, a processing error occurred
             and the details will be contained within the <code>error</code>
             object.
           </td></tr><tr><td class="prmName">quad</td><td class="prmType"><code><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">If there is no error, the quad that was generated.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></section>
    </section>

    <section id="conformancecallback">
      <h4><span class="secno">3.3.4 </span>ConformanceCallback</h4>
      
      <p>The <a href="#idl-def-ConformanceCallback" class="idlType"><code>ConformanceCallback</code></a> <em class="rfc2119" title="may">may</em> be specified in the
      <a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a> via the <code>conformanceCallback</code> parameter.
      If specified, the callback is called whenever a recoverable conformance 
      issue is detected. The developer may then determine whether or not 
      processing should continue based on the type of conformance issue.</p>
  
      <pre class="idl"><span class="idlInterface" id="idl-def-ConformanceCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">ConformanceCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-ConformanceCallback-issue-void-JsonLdProcessingError-issue-function-callback">issue</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdProcessingError" class="idlType"><code>JsonLdProcessingError</code></a></span> <span class="idlParamName">issue</span></span>, <span class="idlParam"><span class="idlParamType"><a>function</a></span> <span class="idlParamName">callback</span></span>);</span>
};</span></pre><section><h5 id="methods-3">Methods</h5><dl class="methods"><dt id="widl-ConformanceCallback-issue-void-JsonLdProcessingError-issue-function-callback"><code>issue</code></dt><dd>This callback is invoked when a conformance issue is detected by
          the JSON-LD processor.
        
        <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">issue</td><td class="prmType"><code><a href="#idl-def-JsonLdProcessingError" class="idlType"><code>JsonLdProcessingError</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">Details about the conformance issue. 
           </td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a>function</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A function that <em class="rfc2119" title="must">must</em> be called when the program has determined
             how to respond to the conformance issue. A single parameter must be
             passed to the callback. The value of the parameter should be  
             <code>null</code> if processing should continue by acting as if the
             key-value that triggered the issue never existed. The 
             <code>issue</code> <em class="rfc2119" title="should">should</em> be passed to the callback without
             modification if processing should stop.</td></tr></table><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></section>
    </section>
  </section>

  <section id="data-structures">
    <h3><span class="secno">3.4 </span>Data Structures</h3>
    <p>This section describes datatype definitions used within the JSON-LD API.</p>

    <section id="iri">
    <h4><span class="secno">3.4.1 </span><abbr title="Internationalized Resource Identifier">IRI</abbr></h4>
    <p>The <a href="#idl-def-IRI" class="idlType"><code>IRI</code></a> datatype is a string representation of an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</p>
    <pre class="idl"><span class="idlTypedef" id="idl-def-IRI">typedef <span class="idlTypedefType"><a>DOMString</a></span> <span class="idlTypedefID">IRI</span>;</span></pre><div class="idlTypedefDesc">
      This datatype indicates that the <em>string</em> is interpreted as an Internationalized
      Resource Identifier [<cite><a class="bibref" href="#bib-RFC3987">RFC3987</a></cite>] identifying a document, which when parsed as JSON yields
      either a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.
    </div>
    </section>

    <section id="jsonldoptions">
    <h4><span class="secno">3.4.2 </span>JsonLdOptions</h4>
    <p>The <a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a> type is used to pass various options to the <a href="#idl-def-JsonLdProcessor" class="idlType"><code>JsonLdProcessor</code></a> methods.</p>
    <pre class="idl"><span class="idlDictionary" id="idl-def-JsonLdOptions">dictionary <span class="idlDictionaryID">JsonLdOptions</span> {
<span class="idlMember">    <span class="idlMemberType"><a href="#idl-def-IRI" class="idlType"><code>IRI</code></a>?</span>     <span class="idlMemberName"><a href="#widl-JsonLdOptions-base">base</a></span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>boolean</a></span>  <span class="idlMemberName"><a href="#widl-JsonLdOptions-compactArrays">compactArrays</a></span> = <span class="idlMemberValue">true</span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>boolean</a></span>  <span class="idlMemberName"><a href="#widl-JsonLdOptions-flatten">flatten</a></span> = <span class="idlMemberValue">false</span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>boolean</a></span>  <span class="idlMemberName"><a href="#widl-JsonLdOptions-optimize">optimize</a></span> = <span class="idlMemberValue">false</span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>boolean</a></span>  <span class="idlMemberName"><a href="#widl-JsonLdOptions-useRdfType">useRdfType</a></span> = <span class="idlMemberValue">false</span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>boolean</a></span>  <span class="idlMemberName"><a href="#widl-JsonLdOptions-useNativeTypes">useNativeTypes</a></span> = <span class="idlMemberValue">true</span>;</span>
<span class="idlMember">    <span class="idlMemberType"><a>function</a></span> <span class="idlMemberName"><a href="#widl-JsonLdOptions-conformanceCallback">conformanceCallback</a></span> = <span class="idlMemberValue">null</span>;</span>
};</span></pre><section><h5 id="dictionary-jsonldoptions-members">Dictionary <a class="idlType" href="#idl-def-JsonLdOptions"><code>JsonLdOptions</code></a> Members</h5><dl class="dictionary-members"><dt id="widl-JsonLdOptions-base"><code>base</code> of type <span class="idlMemberType"><a href="#idl-def-IRI" class="idlType"><code>IRI</code></a></span>, nullable</dt><dd>The Base <abbr title="Internationalized Resource Identifier">IRI</abbr> to use when expanding the document. This overrides the value of
        <em>input</em> if it is a <a href="#idl-def-IRI" class="idlType"><code>IRI</code></a>. If not specified and <em>input</em> is not
        an <a href="#idl-def-IRI" class="idlType"><code>IRI</code></a>, the base <abbr title="Internationalized Resource Identifier">IRI</abbr> defaults to the current document <abbr title="Internationalized Resource Identifier">IRI</abbr> if in a browser context,
        or the empty string if there is no document context.
      </dd><dt id="widl-JsonLdOptions-compactArrays"><code>compactArrays</code> of type <span class="idlMemberType"><a>boolean</a></span>, defaulting to <code>true</code></dt><dd>If set to <code>true</code>, the JSON-LD processor replaces arrays with just
        one element with that element during compaction. If set to <code>false</code>,
        all arrays will remain arrays even if they have just one element.
      </dd><dt id="widl-JsonLdOptions-conformanceCallback"><code>conformanceCallback</code> of type <span class="idlMemberType"><a>function</a></span>, defaulting to <code>null</code></dt><dd>The purpose of this option is to instruct the processor about whether 
        or not it should continue processing. If the value is <code>null</code>,
        the processor should ignore any key-value pair associated with any 
        recoverable conformance issue and continue processing. More details
        about this feature can be found in the <a href="#idl-def-ConformanceCallback" class="idlType"><code>ConformanceCallback</code></a> 
        section.  
      </dd><dt id="widl-JsonLdOptions-flatten"><code>flatten</code> of type <span class="idlMemberType"><a>boolean</a></span>, defaulting to <code>false</code></dt><dd>If set to a value that is not <code>false</code>, 
        the JSON-LD processor must modify the output of the 
        <a href="#compaction-algorithm">Compaction Algorithm</a> 
        or the <a href="#expansion-algorithm">Expansion Algorithm</a> by 
        coalescing all properties associated with each
        <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> via the
        <a href="#flattening-algorithm">Flattening Algorithm</a>. The value
        of <code>flatten</code> <em class="rfc2119" title="must">must</em> be either an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> value
        representing the name of the graph to flatten, or <code>true</code>.
        If the value is <code>true</code>, then the first graph encountered in
        the input document is selected and flattened.   
      </dd><dt id="widl-JsonLdOptions-optimize"><code>optimize</code> of type <span class="idlMemberType"><a>boolean</a></span>, defaulting to <code>false</code></dt><dd>If set to <code>true</code>, the JSON-LD processor is allowed to
        optimize the output of the <a href="#compaction-algorithm">Compaction Algorithm</a>
        to produce even compacter representations. The algorithm for compaction
        optimization is beyond the scope of this specification and thus
        not defined. Consequently, different implementations <em class="rfc2119" title="may">may</em> implement
        different optimization algorithms.
      </dd><dt id="widl-JsonLdOptions-useNativeTypes"><code>useNativeTypes</code> of type <span class="idlMemberType"><a>boolean</a></span>, defaulting to <code>true</code></dt><dd>If set to <code>true</code>, the JSON-LD processor will try to convert
        datatyped literals to JSON native types instead of using the
        expanded object form when <a href="#convert-from-rdf-algorithm">converting from RDF</a>.
        <code>xsd:boolean</code> values will be converted to <a class="tref internalDFN" title="true" href="#dfn-true">true</a> or <a class="tref internalDFN" title="false" href="#dfn-false">false</a>.
        <code>xsd:integer</code> and <code>xsd:double</code> values will be
        converted to
        <a class="tref internalDFN" title="number" href="#dfn-number">JSON numbers</a>.
      </dd><dt id="widl-JsonLdOptions-useRdfType"><code>useRdfType</code> of type <span class="idlMemberType"><a>boolean</a></span>, defaulting to <code>false</code></dt><dd>If set to <code>true</code>, the JSON-LD processor will use the
        expanded <code>rdf:type</code> <abbr title="Internationalized Resource Identifier">IRI</abbr> as the property instead of
        <code>@type</code> when <a href="#convert-from-rdf-algorithm">converting from RDF</a>.
      </dd></dl></section>
    </section>

    <p>The following data structures are used for representing data about
      RDF quads. They are used for normalization, and <a href="#rdf-conversion">RDF conversion</a>.
    </p>

    <section id="quad">
    <h4><span class="secno">3.4.3 </span>Quad</h4>
    <p>The <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> interface represents an RDF Quad.
      See [<cite><a class="bibref" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>] definition for
      <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple">RDF triple</a></cite>,
      which most closely aligns to <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.
    </p>
    <pre class="idl"><span class="idlInterface" id="idl-def-Quad">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Quad</span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-subject">subject</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-property">property</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-object">object</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a>?</span> <span class="idlAttrName"><a href="#widl-Quad-graph">graph</a></span>;</span>
};</span></pre><section><h5 id="attributes">Attributes</h5><dl class="attributes"><dt id="widl-Quad-graph"><code>graph</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly, nullable</dt><dd>If present, the name associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> identifying
        it as a member of a <a class="tref internalDFN" title="named_graph" href="#dfn-named_graph">named graph</a>. If it is missing, the quad
        is a member of the <a class="tref internalDFN" title="default_graph" href="#dfn-default_graph">default graph</a>.
        <div class="issue"><div class="issue-title"><a href="https://github.com/json-ld/json-ld.org/issues/125"><span>Issue 125</span></a></div><div class="">This element is at risk, and may be removed.</div></div>
      </dd><dt id="widl-Quad-object"><code>object</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly</dt><dd>The <a class="tref internalDFN" title="object" href="#dfn-object">object</a> associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.</dd><dt id="widl-Quad-property"><code>property</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly</dt><dd>The <a class="tref internalDFN" title="property" href="#dfn-property">property</a> associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.
        Within JSON-LD, an <dfn title="rdf_predicate" id="dfn-rdf_predicate">RDF predicate</dfn> is refered to as a
        <a class="tref internalDFN" title="property" href="#dfn-property">property</a></dd><dt id="widl-Quad-subject"><code>subject</code> of type <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>, readonly</dt><dd>The <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> associated with the <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>.</dd></dl></section>
    </section>

    <section id="node">
    <h4><span class="secno">3.4.4 </span>Node</h4>
    <p><a class="datatype idlType" title="Node" href="#idl-def-Node"><code>Node</code></a> is the base class of <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>,
    <a class="datatype idlType" title="BlankNode" href="#idl-def-BlankNode"><code>BlankNode</code></a>, and <a class="datatype idlType" title="Literal" href="#idl-def-Literal"><code>Literal</code></a>. It is the IDL
    representation of a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> <a class="tref internalDFN" title="node" href="#dfn-node">node</a>.</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-Node">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Node</span> {
};</span></pre>
    </section>

    <section id="iri-1">
    <h4><span class="secno">3.4.5 </span><abbr title="Internationalized Resource Identifier">IRI</abbr></h4>
    <p>A <a class="tref internalDFN" title="node" href="#dfn-node">node</a> that is an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-IRI-1">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">IRI</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-IRI-value">value</a></span>;</span>
};</span></pre><section><h5 id="attributes-1">Attributes</h5><dl class="attributes"><dt id="widl-IRI-value"><code>value</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>The <abbr title="Internationalized Resource Identifier">IRI</abbr> identifier of the <a class="tref internalDFN" title="node" href="#dfn-node">node</a> as a [<cite><a class="bibref" href="#bib-UNICODE">UNICODE</a></cite>] string.</dd></dl></section>
    </section>

    <section id="blank-node">
    <h4><span class="secno">3.4.6 </span>Blank Node</h4>

    <p>A <a class="tref internalDFN" title="node" href="#dfn-node">node</a> in the <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> that
    does not contain a de-reference-able identifier because it is either
    ephemeral in nature or does not contain information that needs to be linked
    to from outside of the <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.
    A blank node is assigned an identifier starting
    with the prefix <code>_:</code> and an implementation dependent,
    auto-generated suffix that is unique to all information associated with the
    particular blank node.
    </p>

    <pre class="idl"><span class="idlInterface" id="idl-def-BlankNode">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">BlankNode</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-BlankNode-identifier">identifier</a></span>;</span>
};</span></pre><section><h5 id="attributes-2">Attributes</h5><dl class="attributes"><dt id="widl-BlankNode-identifier"><code>identifier</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>The temporary identifier of the <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>.
        The <code>identifier</code> <em class="rfc2119" title="must not">must not</em> be relied upon in any way between two
        separate processing runs of the same document or with a different document.</dd></dl></section>

    <div class="note"><div class="note-title"><span>Note</span></div><p class="">Developers and authors must not assume that the
      value of a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> will remain the same between two
      processing runs. <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> values are only valid for the
      most recent processing run on the document. <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a>
      values will often be generated differently by different processors.</p></div>

    <div class="note"><div class="note-title"><span>Note</span></div><p class="">Implementers <em class="rfc2119" title="must">must</em> ensure that <a href="#idl-def-BlankNode" class="idlType"><code>BlankNode</code></a> values are unique
      within the current environment, two <a class="datatype idlType" title="BlankNode" href="#idl-def-BlankNode"><code>BlankNodes</code></a>
      are considered equal if, and only if, their values are strictly equal.</p></div>
    </section>

    <section id="literal">
      <h4><span class="secno">3.4.7 </span>Literal</h4>
      <p>Literals represent values such as numbers, dates and strings in
        RDF data. A <a class="datatype idlType" title="Literal" href="#idl-def-Literal"><code>Literal</code></a> is comprised of three attributes:
      </p>

      <ul>
        <li>a lexical form of the <code>value</code></li>
        <li>an optional <code>language</code> tag</li>
        <li>a <code>datatype</code> specified by an <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a></li>
      </ul>

      <p>Literals representing plain text in a natural language may have a
        <code>language</code> tag specified by a string token, as specified in
        [<cite><a class="bibref" href="#bib-BCP47">BCP47</a></cite>], normalized to lowercase
        (e.g., <code>'en'</code>, <code>'fr'</code>, <code>'en-gb'</code>).
        They also have a datatype attribute such as <code>xsd:string</code>.
        If unspecified, the <code>datatype</code> defaults to <code>xsd:string</code>.
      </p>

      <p>Literals representing values with a specific datatype, such as
        the integer 72, may have a <code>datatype</code> attribute specified in the form
        of a <a href="#idl-def-IRI" class="idlType"><code>IRI</code></a> (e.g.,
        <code>xsd:integer</code>).</p>

      <p> See[<cite><a class="bibref" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>] definition for
      <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-literal">literal</a></cite>.</p>

      <pre class="idl"><span class="idlInterface" id="idl-def-Literal">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Literal</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span>  <span class="idlAttrName"><a href="#widl-Literal-value">value</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a>?</span> <span class="idlAttrName"><a href="#widl-Literal-language">language</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-IRI" class="idlType"><code>IRI</code></a>?</span>       <span class="idlAttrName"><a href="#widl-Literal-datatype">datatype</a></span>;</span>
};</span></pre><section><h5 id="attributes-3">Attributes</h5><dl class="attributes"><dt id="widl-Literal-datatype"><code>datatype</code> of type <span class="idlAttrType"><a href="#idl-def-IRI" class="idlType"><code>IRI</code></a></span>, readonly, nullable</dt><dd>An optional datatype identified by a <abbr title="Internationalized Resource Identifier">IRI</abbr>.</dd><dt id="widl-Literal-language"><code>language</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly, nullable</dt><dd>An optional language tag as defined in [<cite><a class="bibref" href="#bib-BCP47">BCP47</a></cite>], normalized to lowercase.</dd><dt id="widl-Literal-value"><code>value</code> of type <span class="idlAttrType"><a>DOMString</a></span>, readonly</dt><dd>The lexical form of the Literal's value.</dd></dl></section>
    </section>
  </section>

</section>

<section id="algorithms">

<!--OddPage-->
<h2><span class="secno">4. </span>Algorithms</h2>

<p>All algorithms described in this section are intended to operate on
language-native data structures. That is, the serialization to a text-based
JSON document isn't required as input or output to any of these algorithms and
language-native data structures <em class="rfc2119" title="must">must</em> be used where applicable.</p>

<section id="algorithm-terms">
  <h3><span class="secno">4.1 </span>Algorithm Terms</h3>
  <dl>
    <dt><dfn title="active_subject" id="dfn-active_subject">active subject</dfn></dt>
    <dd>
      the currently active subject that the processor should use when
      processing.
    </dd>
    <dt><dfn title="active_property" id="dfn-active_property">active property</dfn></dt>
    <dd>
      the currently active property that the processor should use when
      processing. The active property is represented in the original lexical form, which
      is used for finding coercion mappings in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.
    </dd>
    <dt><dfn title="active_object" id="dfn-active_object">active object</dfn></dt>
    <dd>
      the currently active object that the processor should use when
      processing.
    </dd>
    <dt><dfn title="active_context" id="dfn-active_context">active context</dfn></dt>
    <dd>
      a context that is used to resolve <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s while the processing
      algorithm is running. The <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is the context
      contained within the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.
    </dd>
    <dt><dfn title="compact_iri" id="dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></dfn></dt>
    <dd>
      a compact <abbr title="Internationalized Resource Identifier">IRI</abbr> is has the form of <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a> and <em>suffix</em> and is used as a way
      of expressing an <abbr title="Internationalized Resource Identifier">IRI</abbr> without needing to define separate <a class="tref internalDFN" title="term" href="#dfn-term">term</a> definitions for
      each <abbr title="Internationalized Resource Identifier">IRI</abbr> contained within a common vocabulary identified by <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>.
    </dd>
    <dt><dfn title="local_context" id="dfn-local_context">local context</dfn></dt>
    <dd>
      a context that is specified within a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>,
      specified via the <code>@context</code> <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>.
    </dd>
    <dt><dfn title="processor_state" id="dfn-processor_state">processor state</dfn></dt>
    <dd>
      the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>, which includes the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active
      context</a>, <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, and
      <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>. The <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> is managed
      as a stack with elements from the previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>
      copied into a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> when entering a new
      <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.
    </dd>
    <dt><dfn title="json-ld_input" id="dfn-json-ld_input">JSON-LD input</dfn></dt>
    <dd>
      The JSON-LD data structure that is provided as input to the algorithm.
    </dd>
    <dt><dfn title="json-ld_output" id="dfn-json-ld_output">JSON-LD output</dfn></dt>
    <dd>
      The JSON-LD data structure that is produced as output by the algorithm.
    </dd>
    <dt><dfn title="term" id="dfn-term">term</dfn></dt><dd>
      A <a class="tref internalDFN" title="term" href="#dfn-term">term</a> is a short word defined in a context that <em class="rfc2119" title="may">may</em> be expanded to an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>
    </dd>
    <dt><dfn title="prefix" id="dfn-prefix">prefix</dfn></dt><dd>
      A <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a> is a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> that expands to a vocabulary base <abbr title="Internationalized Resource Identifier">IRI</abbr>. It
      is typically used along with a <em>suffix</em> to form a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> to create an <abbr title="Internationalized Resource Identifier">IRI</abbr>
      within a vocabulary.
    </dd>
    <dt><dfn title="language-tagged_string" id="dfn-language-tagged_string">language-tagged string</dfn></dt><dd>
      A <a class="tref internalDFN" title="language-tagged_string" href="#dfn-language-tagged_string">language-tagged string</a> is a <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a> without a datatype, including
      a language. See <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-language-tagged-string">languaged-tagged string</a></cite>
      in [<cite><a class="bibref" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>].
    </dd>
    <dt><dfn title="typed_literal" id="dfn-typed_literal">typed literal</dfn></dt><dd>
      A <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> is a <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a> with an associated <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>
      which indicates the literal's datatype. See <cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-literal">literal</a></cite>
      in [<cite><a class="bibref" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>].
    </dd>
  </dl>
</section>

<section id="context-processing">
  <h3 id="context"><span class="secno">4.2 </span>Context Processing</h3>
  <p>Processing of JSON-LD data structure is managed recursively.
    During processing, each rule is applied using information provided by the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.
    Processing begins by pushing a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> onto the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> stack.
    If a <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is encountered, information from the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is merged
    into the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</p>
  <p>The <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is used for expanding properties and values of a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> (or elements
    of an array) using a <dfn title="term_mapping" id="dfn-term_mapping">term mapping</dfn>. It is also used to maintain
    <dfn title="coercion_mapping" id="dfn-coercion_mapping">coercion mapping</dfn>s from terms to datatypes, <dfn title="language_mapping" id="dfn-language_mapping">language mapping</dfn>s from terms to language codes,
    and <dfn title="list_mapping" id="dfn-list_mapping">list mapping</dfn>s and <dfn title="set_mapping" id="dfn-set_mapping">set mapping</dfn>s for terms. Processors <em class="rfc2119" title="must">must</em> use the
    lexical form of the property when creating a mapping, as lookup is performed on lexical forms, not
    expanded <abbr title="Internationalized Resource Identifier">IRI</abbr> representations.</p>
  <p>A <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is identified within a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> having a <code>@context</code>
    property with a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, <a class="tref internalDFN" title="array" href="#dfn-array">array</a> or a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> value.
    When processing a <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>, special processing rules apply:</p>
  <ol class="algorithm">
    <li>Create a new, empty <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
    <li>Let <em>context</em> be the value of <code>@context</code>
      <ol class="algorithm">
        <li id="process-context">If <em>context</em> equals <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, clear the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
        <li>If <em>context</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each element as <em>context</em> in order
          by starting at <a href="#process-context">Step 2.1</a>.</li>
        <li>If <em>context</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, it <em class="rfc2119" title="must">must</em> have a lexical form of <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.
          <ol class="algorithm">
            <li>Expand <em>context</em> according to <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.</li>
            <li>Dereference <em>context</em>.</li>
            <li>If the resulting document is a JSON document, extract the top-level <code>@context</code>
              element using the JSON Pointer &quot;/@context&quot; as described in [<cite><a class="bibref" href="#bib-JSON-POINTER">JSON-POINTER</a></cite>]. Set <em>context</em>
              to the extracted content and process it by starting at <a href="#process-context">Step 2.1</a>.</li>
          </ol>
        </li>
        <li>If <em>context</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>, perform the following steps:
          <ol class="algorithm">
            <li>If <em>context</em> has a <code>@language</code> property, it <em class="rfc2119" title="must">must</em> have a value of a
              simple <a class="tref internalDFN" title="string" href="#dfn-string">string</a> with the lexical form described in [<cite><a class="bibref" href="#bib-BCP47">BCP47</a></cite>], or <a class="tref internalDFN" title="null" href="#dfn-null">null</a>. Add the language to the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
            <li>If <em>value</em> has a <code>@vocab</code> key, it <em class="rfc2119" title="must">must</em> have a value of a simple <a class="tref internalDFN" title="string" href="#dfn-string">string</a>
              with the lexical form of an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or <a class="tref internalDFN" title="null" href="#dfn-null">null</a>. Add the vocabulary mapping to the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
            <li id="object-context">Otherwise, for each property in <em>context</em> perform the following steps:
              <ol class="algorithm">
                <li>If the property's value is a simple <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping value by
                  performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated value. If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr>
                  mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, merge the property into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>
                  <a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">term mapping</a>, unless the property is a JSON-LD <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>, in which
                  case return an error.</li>
                <li>Otherwise, if the property's value is <a class="tref internalDFN" title="null" href="#dfn-null">null</a> remove mapping, coercion,
                  container and language information associated with property from the
                  <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
                <li>Otherwise, the <em>property</em>'s <em>value</em> <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.
                  <ol class="algorithm">
                    <li>If the <em>property</em> is a JSON-LD <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a> and the value has
                      <code>@id</code>, <code>@language</code> or <code>@type</code> properties, return an error.
                      <div class="issue"><div class="issue-title"><span>Issue</span></div><div class="">Undecided if <code>@type</code> or <code>@graph</code> can take a
                        <code>@container</code> with <code>@set</code>.
                      </div></div>
                    </li>
                    <li>If the <em>property</em> has the form of <a class="tref internalDFN" title="term" href="#dfn-term">term</a>, its <em>value</em> <em class="rfc2119" title="must">must</em> have an
                      <code>@id</code> property with a string value which <em class="rfc2119" title="must">must</em> have the form of a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>,
                      <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>. Determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping
                      by performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated value.
                      If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, merge the
                      <em>property</em> into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> <a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">term mapping</a>.</li>
                    <li>If the <em>property</em> has the form of of a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> or <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>,
                      the <em>value</em> <em class="rfc2119" title="may">may</em> have a <code>@id</code> property with a string value which <em class="rfc2119" title="must">must</em> have the
                      form of a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>, <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or absolute <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>.
                      Determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping by performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated
                      value. If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, merge the
                      <em>property</em> into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> <a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">term mapping</a>.</li>
                    <li>If the <em>value</em> has a <code>@type</code> property, its value <em class="rfc2119" title="must">must</em> have the form of a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>,
                      <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or the <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a> <code>@id</code>.
                      Determine the <abbr title="Internationalized Resource Identifier">IRI</abbr> by performing <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> on the associated value.
                      If the result of the <abbr title="Internationalized Resource Identifier">IRI</abbr> mapping is an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a> or <code>@id</code>, merge into the
                      <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> <a class="tref internalDFN" title="coercion_mapping" href="#dfn-coercion_mapping">coercion mapping</a> using the lexical value of the <em>property</em>.</li>
                    <li>If the <em>value</em> has a <code>@container</code> property, its value <em class="rfc2119" title="must">must</em> be <code>@list</code> or
                      <code>@set</code>. Merge the <a class="tref internalDFN" title="list_mapping" href="#dfn-list_mapping">list mapping</a> or <a class="tref internalDFN" title="set_mapping" href="#dfn-set_mapping">set mapping</a> into the
                      <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> using the lexical value of the <em>property</em>.</li>
                    <li>If the <em>value</em> has a <code>@language</code> property but no <code>@type</code> property, the value of the
                      <code>@language</code> property <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="string" href="#dfn-string">string</a> or <a class="tref internalDFN" title="null" href="#dfn-null">null</a>.
                      Merge the <a class="tref internalDFN" title="language_mapping" href="#dfn-language_mapping">language mapping</a> into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> using the lexical value of the
                      <em>property</em>.</li>
                  </ol>
                </li>
                <li>Merge the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> into the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
                <li>Repeat <a href="#object-context">Step 2.4.2</a> until no entries are added to the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local
                  context</a>.</li>
              </ol>
            </li>
          </ol>
        </li>
      </ol>
    </li>
  </ol>

  <div class="note"><div class="note-title"><span>Note</span></div><p class="">It can be difficult to distinguish between a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> and an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>,
    as a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> may seem to be a valid <abbr title="Internationalized Resource Identifier">IRI</abbr> <em>scheme</em>. When performing repeated <abbr title="Internationalized Resource Identifier">IRI</abbr> expansion,
    a term used as a prefix may not have a valid mapping due to dependencies in resolving term definitions. By
    continuing <a href="#object-context">Step 2.3.2</a> until no changes are made, mappings to IRIs created
    using an undefined term prefix will eventually expand to an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>s.</p></div>

</section>

<section id="iri-expansion">
  <h3><span class="secno">4.3 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</h3>
  <p>Keys and some values are evaluated to produce an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>. This section defines an algorithm for
    transforming a value representing an <abbr title="Internationalized Resource Identifier">IRI</abbr> into an actual <abbr title="Internationalized Resource Identifier">IRI</abbr>.</p>
  <p><a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a> may be represented as an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>,
    a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a>, or as a value relative to <code>@vocab</code>.</p>
  <p>An <dfn title="absolute_iri" id="dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></dfn> is defined in [<cite><a class="bibref" href="#bib-RFC3987">RFC3987</a></cite>] containing a <em>scheme</em> along with
    <em>path</em> and optional <em>query</em> and fragment segments. A <dfn title="relative_iri" id="dfn-relative_iri">relative <abbr title="Internationalized Resource Identifier">IRI</abbr></dfn> is an <abbr title="Internationalized Resource Identifier">IRI</abbr>
    that is relative some other <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a>; in the case of JSON-LD this is the base location
    of the document.</p>

  <p>The algorithm for generating an <abbr title="Internationalized Resource Identifier">IRI</abbr> is:
    </p><ol class="algorithm">
      <li>If the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> mapping for the value using
        a case-sensitive comparison, use the mapped value as an <abbr title="Internationalized Resource Identifier">IRI</abbr>.</li>
      <li>Otherwise, split the value into a <em>prefix</em> and <em>suffix</em> from the first occurrence of ':'.</li>
      <li>If the prefix is a '_' (underscore), the value represents a named <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>.</li>
      <li>If the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> mapping for <em>prefix</em> using
        a case-sensitive comparison, and <em>suffix</em> does not does not begin with '//'
        (i.e., it does not match a <em>hier-part</em> including
        <em>authority</em> (as defined in [<cite><a class="bibref" href="#bib-RFC3986">RFC3986</a></cite>]), generate an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>
        by prepending the mapped prefix to the (possibly empty) suffix using textual concatenation. Note that an empty
        suffix and no suffix (meaning the value contains no ':' string at all) are treated equivalently.</li>
      <li>Otherwise, if the <abbr title="Internationalized Resource Identifier">IRI</abbr> being processed does not contain a colon and is a property, i.e., a key in
        a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>, or the value of <code>@type</code> and the active context has a
        <code>@vocab</code> mapping, join the mapped value to the suffix using textual concatenation.</li>
      <li>Otherwise, if the <abbr title="Internationalized Resource Identifier">IRI</abbr> being processed does not contain a colon and is not a property, i.e., not a key in a
        <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> treat it as a <a class="tref internalDFN" title="relative_iri" href="#dfn-relative_iri">relative <abbr title="Internationalized Resource Identifier">IRI</abbr></a> and resolve it against the base <abbr title="Internationalized Resource Identifier">IRI</abbr> as
        per [<cite><a class="bibref" href="#bib-RFC3986">RFC3986</a></cite>] using only the basic algorithm in section 5.2. Neither <em>Syntax-Based Normalization</em>
        nor <em>Scheme-Based Normalization</em> (described in sections 6.2.2 and 6.2.3 of [<cite><a class="bibref" href="#bib-RFC3986">RFC3986</a></cite>]) are performed.
        Characters additionally allowed in <abbr title="Internationalized Resource Identifier">IRI</abbr> references are treated in the same way that unreserved characters are
        treated in URI references, per section 6.5 of [<cite><a class="bibref" href="#bib-RFC3987">RFC3987</a></cite>].</li>
      <li>Otherwise, use the value directly as an <abbr title="Internationalized Resource Identifier">IRI</abbr>.</li>
    </ol>
  <p></p>
</section>

<section id="iri-compaction">
  <h3><span class="secno">4.4 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</h3>
  <p>Some keys and values are expressed using <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>s. This section defines an
    algorithm for transforming an <abbr title="Internationalized Resource Identifier">IRI</abbr> (<em>iri</em>) to a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> or <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> using the
    <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s specified in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> using an optional <em>value</em>.</p>

<section id="iri-compaction-algorithm">
  <h4><span class="secno">4.4.1 </span><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction Algorithm</h4>
  <p>The algorithm for generating a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is:
    </p><ol class="algorithm">
      <li>Create an empty list of terms <em>terms</em> that will be populated with
        <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s that are ranked according to how closely they match
        <em>value</em>. Initialize <em>highest rank</em> to <code>0</code>,
        and set a flag <em>list container</em> to <code>false</code>.</li>
      <li>For each <em>term</em> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>:
        <ol class="algorithm">
          <li>If the <em>term</em>'s <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> is not a complete match against
            <em>iri</em>, continue to the next <em>term</em>.</li>
          <li>If <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing only the property <code>@list</code>:
            <ol class="algorithm">
              <li>If <em>term</em> has a <code>@container</code> set to <code>@set</code>, continue
                to the next <em>term</em>.</li>
              <li>If <em>list container</em> is <code>true</code> and <em>term</em> does not have a
                <code>container</code> set to <code>@list</code> and <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
                continue to the next <em>term</em>.</li>
            </ol>
          </li>
          <li>Otherwise, if <em>term</em> has a <code>container</code> set to <code>@list</code>,
            continue to the next <em>term</em>.</li>
          <li>Set <em>rank</em> to the <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> of <em>value</em> by passing
            passing <em>term</em>, <em>value</em>, and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> to
            the <a href="#term-rank-algorithm">Term Rank Algorithm</a>.</li>
          <li>If <em>rank</em> is greater than <code>0</code>:
            <ol class="algorithm">
              <li>If <em>term</em> has a <code>container</code> set to <code>@set</code>, then add
                <code>1</code> to <em>rank</em>.</li>
              <li>If <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing only the property <code>@list</code>
                and <em>list container</em> is <code>false</code> and <em>term</em> has a <code>container</code>
                set to <code>@list</code>, then set <em>list container</em> to <code>true</code>, clear
                <em>terms</em>, set <em>highest rank</em> to <em>rank</em>, and add <em>term</em> to <em>terms</em>.</li>
              <li>Otherwise, if <em>rank</em> is greater than or equal to <em>highest rank</em>:
                <ol class="algorithm">
                  <li>If <em>rank</em> is greater than <em>highest rank</em>, clear <em>terms</em> and set
                    <em>highest rank</em> to <em>rank</em>.</li>
                  <li>Add <em>term</em> to <em>terms</em>.</li>
                </ol>
              </li>
            </ol>
          </li>
        </ol>
      </li>
      <li>If <em>terms</em> is empty, and the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> has a <code>@vocab</code>
        which is a prefix of <em>iri</em> where
        the resulting <a class="tref internalDFN" title="relative_iri" href="#dfn-relative_iri">relative <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is not a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> in the
        <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. The resulting <a class="tref internalDFN" title="relative_iri" href="#dfn-relative_iri">relative <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is the
        unmatched part of <em>iri</em>.</li>
      <li>If <em>terms</em> is empty, add a <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> representation of <em>iri</em>
        for each <a class="tref internalDFN" title="term" href="#dfn-term">term</a> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> which
        maps to an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> which is a prefix for <em>iri</em> where
        the resulting <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is not a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> in the
        <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. The resulting <a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">compact <abbr title="Internationalized Resource Identifier">IRI</abbr></a> is the
        <a class="tref internalDFN" title="term" href="#dfn-term">term</a> associated with the partially
        matched <abbr title="Internationalized Resource Identifier">IRI</abbr> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> concatenated with a
        colon (:) character and the unmatched part of <em>iri</em>.</li>
      <li>If <em>terms</em> is empty, the <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> being processed is a property or the
        value of <code>@type</code> and <code>@vocab</code> is not null and matches the beginning
        of <em>iri</em>, return the unmatched portion of <em>iri</em>. Otherwise return
        <em>iri</em>.</li>
      <li>Otherwise, return the shortest and lexicographically least value in <em>terms</em>.</li>
    </ol>
  <p></p>
</section>

<section id="term-rank-algorithm">
<h4><span class="secno">4.4.2 </span>Term Rank Algorithm</h4>
<p>When selecting among multiple possible terms for a given property, it may be that multiple
  <a class="tref internalDFN" title="term" href="#dfn-term">terms</a> are defined with the same <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>, but differ in <code>@type</code>, <code>@container</code>
  or <code>@language</code>. The purpose of this algorithm is to take a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>
  and a value and give it a <dfn title="term_rank" id="dfn-term_rank">term rank</dfn>. The selection can then be based, partly, on
  the term having the highest <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>.</p>
<p>Given a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> <em>term</em>, <em>value</em>, and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>
  determine the <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> using the following steps:</p>
<ol class="algorithm">
  <li>If <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>3</code>.</li>
  <li>Otherwise, if <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing only the property <code>@list</code>:
    <ol class="algorithm">
      <li>If the <code>@list</code> property is an empty array, if <em>term</em> has <code>@container</code>
        set to <code>@list</code>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>1</code>, otherwise <code>0</code>.</li>
      <li>Otherwise, return the sum of the <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>s for every entry in the list.</li>
    </ol>
  </li>
  <li>Otherwise, <em>value</em> <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="node_definition" href="#dfn-node_definition">node definition</a>, <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>,
    or a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> having a <code>@value</code>.
    <ol class="algorithm">
      <li>If <em>value</em> has a <code>@value</code> property:
        <ol class="algorithm">
          <li>If <em>value</em> has a <code>@type</code> property matching a
            <code>@type</code> coercion for <em>term</em>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>
            is <code>3</code>, otherwise if <em>term</em> has no <code>@type</code>
            coercion and no <code>@language</code>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is
            <code>1</code>, otherwise <code>0</code>.</li>
          <li>Otherwise, if <code>@value</code> is not a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, if <em>term</em> has
            no <code>@type</code> or <code>@language</code> it is <code>2</code>, otherwise <code>1</code>.</li>
          <li>Otherwise, if <em>value</em> has no <code>@language</code> property, if <em>term</em> has
            <code>@language</code> <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, or <em>term</em> has no <code>@type</code> or
            <code>@language</code> and the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> has no <code>@language</code>,
            <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>3</code>, otherwise <code>0</code>.</li>
          <li>Otherwise, if <em>value</em> has a <code>@language</code> property matching a
            <code>@language</code> definition for <em>term</em> (or
            <em>term</em> has no <code>@type</code> or <code>@language</code> definition and
            <code>@language</code> in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> matches the
            <em>value</em> <code>@language</code>), <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is
            <code>3</code>, otherwise if <em>term</em> has no <code>@type</code>
            coercion and no <code>@language</code>, <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is
            <code>1</code>, otherwise <code>0</code>.</li>
        </ol>
      </li>
      <li>Otherwise, if <em>term</em> has <code>@type</code> coerced to <code>@id</code>,
        <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>3</code>, otherwise
        if <em>term</em> has no <code>@type</code> coercion and no <code>@language</code>,
        <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a> is <code>1</code>, otherwise <code>0</code>.</li>
    </ol>
  </li>
  <li>Return <a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">term rank</a>.</li>
</ol>
</section>

</section>

<section id="value-expansion">
  <h3><span class="secno">4.5 </span>Value Expansion</h3>
  <p>Some values in JSON-LD can be expressed in a compact form. These values
    are required to be expanded at times when processing JSON-LD documents.</p>

  <p>The algorithm for expanding a <em>value</em> takes an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
    and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. It is implemented as follows:</p>
  <ol class="algorithm">
    <li>If <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, the <em>value</em> is already expanded.</li>
    <li>If <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is <code>@graph</code> or the target of an <code>@id</code> coercion,
      expand the value into an object with a key-value pair where the key is <code>@id</code> and the value is
      the expanded <abbr title="Internationalized Resource Identifier">IRI</abbr> according to the <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> rules.</li>
    <li>Otherwise, if <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is not a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>, then expand <em>value</em> into an
      object:
      <ol class="algorithm">
        <li>Set the first key-value pair to <code>@value</code> and the unexpanded <em>value</em>.</li>
        <li>If the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is the target of typed literal coercion, set the second key-value pair
          to <code>@type</code> and the associated coercion datatype expanded according to the
          <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a> rules.</li>
        <li>Otherwise, if the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is the target of language tagging, set the second key-value
          pair to <code>@language</code> and value of the language tagging from the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
      </ol>
    </li>
    <li>Otherwise, <em>value</em> is already expanded.</li>
  </ol>
</section>

<section id="value-compaction">
  <h3><span class="secno">4.6 </span>Value Compaction</h3>
  <p>Some values, such as <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a> and <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literals</a>, may be expressed in an
    expanded form (<dfn title="expanded_value" id="dfn-expanded_value">expanded value</dfn>) in JSON-LD. These values are required to be compacted at
    times when processing JSON-LD documents.
  </p>

  <p>The algorithm for compacting an expanded value <em>value</em> takes an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
    and <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. It is implemented as follows:</p>
  <ol class="algorithm">
    <li>If <em>value</em> only has one property and the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> has no default language,
      then the compacted value is the value of <code>@value</code>.</li>
    <li>Otherwise, if <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is <code>@graph</code>, the compacted value is the
      value associated with the <code>@id</code> key, processed according to
      the <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
    <li>Otherwise, if the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a coercion target for the
      key that matches the expression of the value, compact the value using the
      following steps:
      <ol class="algorithm">
        <li>If the coercion target is an <code>@id</code>, the compacted
          value is the value associated with the <code>@id</code> key,
          processed according to the
          <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
        <li>If the coercion target is a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>, the compacted
          value is the value associated with the <code>@value</code> key.</li>
      </ol>
    </li>
    <li>Otherwise, if <em>value</em> contains an <code>@id</code> key, the compacted value is <em>value</em> with
      the value of <code>@id</code> processed according to the
      <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
    <li>Otherwise, if the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a <code>@language</code>, which
      matches the <code>@language</code> of the value, or the value has only a <code>@value</code> key, the compacted
      value is the value associated with the <code>@value</code> key.</li>
    <li>Otherwise, if the value contains a <code>@type</code> key, the compacted value
      is <em>value</em> with the <code>@type</code> value processed according to the
      <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> steps.</li>
    <li>Otherwise, the value is not modified.</li>
  </ol>
</section>

<section id="expansion-1">
<h3><span class="secno">4.7 </span>Expansion</h3>

<p>Expansion is the process of taking a JSON-LD document and applying a
  context such that all <abbr title="Internationalized Resource Identifier">IRI</abbr>, datatypes, and literal values are expanded so
  that the context is no longer necessary. JSON-LD document expansion
  is typically used as a part of other JSON-LD API methods.</p>

<p>For example, assume the following JSON-LD input document:</p>

<div class="example"><div class="example-title"><span>Example 13</span></div><pre class="example">{
   &quot;@context&quot;:
   {
      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: {
        &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
        &quot;@type&quot;, &quot;@id&quot;
      }
   },
   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre></div>

<p>Running the JSON-LD Expansion algorithm against the JSON-LD input document
  provided above would result in the following output:</p>

<div class="example"><div class="example-title"><span>Example 14</span></div><pre class="example">{
   &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
   &quot;http://xmlns.com/foaf/0.1/homepage&quot;: {
      &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
   }
}</pre></div>

<section id="expansion-algorithm">
<h4><span class="secno">4.7.1 </span>Expansion Algorithm</h4>

<p>The algorithm takes three input variables: an <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>,
  an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, and an <em>element</em> to be expanded. To
  begin, the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is set to the result of performing, <a href="#context-processing">Context Processing</a> on the passed
  <em>context</em>, or empty if <em>context</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
  <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is set to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and
  <em>element</em> is set to the <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD input</a>.</p>
<ol class="algorithm">
  <li>If <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each entry in <em>element</em> recursively
    using this algorithm, passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
    If has a <code>@container</code> set to <code>@list</code> and any entry in <em>element</em> is an
    <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, or is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing a <code>@list</code> property,
    return an error, as lists of lists are not allowed.
    If the expanded entry is null, drop it. If it's an array, merge its entries with <em>element</em>'s entries.</li>
  <li>Otherwise, if <em>element</em> is an object
    <ol class="algorithm">
      <li>If <em>element</em> has a <code>@context</code> property, update the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> according to
        the steps outlined in <a href="#context-processing">Context Processing</a> and remove the <code>@context</code>
        property.</li>
      <li>Then, proceed and process each <em>property</em> and <em>value</em> in <em>element</em> as follows:
        <ol class="algorithm">
          <li>Remove <em>property</em> from <em>element</em>, expand
            <em>property</em> according to the steps outlined in <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.
            Set the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the original un-expanded <em>property</em> if
            <em>property</em> is not a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>.</li>
          <li>If <em>property</em> does not expand to a keyword or an <a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">absolute <abbr title="Internationalized Resource Identifier">IRI</abbr></a> (i.e., it doesn't contain a colon),
            continue with the next property from <em>element</em>.</li>
          <li>If <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a> and <em>property</em> is not <code>@value</code>, continue with the next
            property from <em>element</em>.</li>
          <li>If the <em>property</em> is <code>@id</code> the <em>value</em> <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>.
            Expand the <em>value</em> according to <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.</li>
          <li>Otherwise, if the <em>property</em> is <code>@type</code>:
            <ol class="algorithm">
              <li>If <em>value</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, expand according to <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.</li>
              <li>Otherwise, if <em>value</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON Object</a>, it must be empty (used for
                <cite><a href="../json-ld-framing/#framing">Framing</a></cite>).</li>
              <li>Otherwise, if <em>value</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, all elements must be <a class="tref internalDFN" title="string" href="#dfn-string">string</a>s.
                Expand <em>value</em> for each of its entries according to <a href="#iri-expansion"><abbr title="Internationalized Resource Identifier">IRI</abbr> Expansion</a>.</li>
            </ol>
          </li>
          <li>Otherwise, if the <em>property</em> is <code>@value</code> or <code>@language</code> the <em>value</em> <em class="rfc2119" title="must not">must not</em> be a
            <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
          <li>Otherwise, if the <em>property</em> is <code>@list</code> or <code>@set</code> expand <em>value</em>
            recursively using this algorithm, passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and <em>active property</em>. If the expanded
            <em>value</em> is not an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, convert it to an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.
            If <em>property</em> is <code>@list</code> and any entry in <em>value</em> is a
            <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing an <code>@list</code> property, return an error, as
            lists of lists are not supported.</li>
          <li>Otherwise, expand <em>value</em> recursively using this algorithm, passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and
            <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
          <li>If <em>property</em> is not a keyword
            and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> has a <code>@container</code> <code>@list</code>
            and the expanded <em>value</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
            convert <em>value</em> to an <a class="tref internalDFN" title="object" href="#dfn-object">object</a> with an <code>@list</code> property whose value is
            set to <em>value</em> (unless <em>value</em> is already in that form).</li>
          <li>Convert <em>value</em> to <a class="tref internalDFN" title="array" href="#dfn-array">array</a> form unless <em>value</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a> or <em>property</em> is
            <code>@id</code>, <code>@type</code>, <code>@value</code>, or <code>@language</code>.</li>
          <li>If <em>value</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, either merge <em>value</em> into an existing <em>property</em> property of
            <em>element</em> or create a new <em>property</em> property with <em>value</em> as value.</li>
        </ol>
      </li>
      <li>If the processed <em>element</em> has an <code>@value</code> property
        <ol class="algorithm">
          <li><em>element</em> <em class="rfc2119" title="must not">must not</em> have more than one other property, which can either be <code>@language</code> or <code>@type</code>
            with a <a class="tref internalDFN" title="string" href="#dfn-string">string</a> value.</li>
          <li>if the value of <code>@value</code> equals <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
            replace <em>element</em> with the value of <code>@value</code>.</li>
        </ol>
      </li>
      <li>Otherwise, if <em>element</em> has an <code>@type</code> property and its value is not in the form of an
        <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, convert it to an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
      <li>If <em>element</em> has an <code>@set</code> or <code>@list</code> property, it <em class="rfc2119" title="must">must</em> be the only property.
        Set <em>element</em> to the value of <code>@set</code>; leave <code>@list</code> untouched.</li>
      <li>If <em>element</em> has just a <code>@language</code> property, set <em>element</em> to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>.</li>
    </ol>
  </li>
  <li>Otherwise, expand <em>element</em> according to the <a href="#value-expansion">Value Expansion</a> rules,
    passing copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
</ol>

<p>If, after the algorithm outlined above is run, the resulting <em>element</em> is an <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with just a <code>@graph</code>
  property, <em>element</em> is set to the value of <code>@graph</code>'s value. Finally, if <em>element</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>,
  it is wrapped into an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</p>

</section>

</section>

<section id="compaction-1">
<h3><span class="secno">4.8 </span>Compaction</h3>

<p>Compaction is the process of taking a JSON-LD document and applying a
  context such that the most compact form of the document is generated. JSON
  is typically expressed in a very compact, key-value format. That is, full
  IRIs are rarely used as keys. At times, a JSON-LD document may be received
  that is not in its most compact form. JSON-LD, via the API, provides a way
  to compact a JSON-LD document.</p>

<p>For example, assume the following JSON-LD input document:</p>

<div class="example"><div class="example-title"><span>Example 15</span></div><pre class="example">{
  &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: {
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }
}</pre></div>

<p>Additionally, assume the following developer-supplied JSON-LD context:</p>

<div class="example"><div class="example-title"><span>Example 16</span></div><pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: {
      &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@type&quot;: &quot;@id&quot;
    }
  }
}</pre></div>

<p>Running the JSON-LD Compaction algorithm given the context supplied above
  against the JSON-LD input document provided above would result in the following
  output:</p>

<div class="example"><div class="example-title"><span>Example 17</span></div><pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: {
      &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@type&quot;: &quot;@id&quot;
    }
  },
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}</pre></div>

<p>The compaction algorithm also enables the developer to map any expanded
  format into an application-specific compacted format. While the context
  provided above mapped <code>http://xmlns.com/foaf/0.1/name</code> to
  <strong>name</strong>, it could have also mapped it to any arbitrary string
  provided by the developer.</p>

<section id="compaction-algorithm">
<h4><span class="secno">4.8.1 </span>Compaction Algorithm</h4>

<p>The algorithm takes three input variables: an <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>, an <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>,
  and an <em>element</em> to be compacted. To begin, the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is
  set to the result of performing <a href="#context-processing">Context Processing</a> on the passed <em>context</em>,
  <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is set to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and <em>element</em> is set to the result of performing the
  <a href="#expansion-algorithm">Expansion Algorithm</a> on the <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD input</a>. This removes any existing
  context to allow the given <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> to be cleanly applied.</p>

<ol class="algorithm">
  <li>If <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each entry in <em>element</em> recursively
    using this algorithm, passing a copy of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
    If <em>element</em> has a single item and the
    <code class="idlMemberName"><a href="#widl-JsonLdOptions-compactArrays">compactArrays</a></code> option is set to
    <code>true</code>, the compacted value is that item; otherwise the compacted value is <em>element</em>.</li>
  <li>Otherwise, if <em>element</em> is an object:
    <ol class="algorithm">
      <li>If <em>element</em> has an <code>@value</code> property or element is a <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>,
        return the result of performing
        <a href="#value-compaction">Value Compaction</a> on <em>element</em> using <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
      <li>Otherwise, if the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> has a <code>@container</code> mapping to <code>@list</code>
        and <em>element</em> has a corresponding <code>@list</code> property, recursively compact that
        property's value passing a copy of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> ensuring
        that the result is an array with all <a class="tref internalDFN" title="null" href="#dfn-null">null</a> values removed. If there already exists a value for
        <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> in <em>element</em> and the full <abbr title="Internationalized Resource Identifier">IRI</abbr> of <em>property</em> is also coerced to
        <code>@list</code>, return an error. Otherwise store the resulting array as value of <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
        if empty or <em>property</em> otherwise.</li>
      <li>Otherwise, construct <em>output</em> as a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> used for returning the result
        of compacting <em>element</em>. For each <em>property</em> and <em>value</em> in <em>element:</em>
        <ol class="algorithm">
          <li>If <em>property</em> is <code>@id</code> or <code>@type</code>
            <ol class="algorithm">
              <li>Set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the result of performing
                <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> on <em>property</em>.</li>
              <li>If <em>value</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, the compacted <em>value</em> is the result of performing
                <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> on <em>value</em>.</li>
              <li>Otherwise, <em>value</em> <em class="rfc2119" title="must">must</em> be an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>. Perform <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a>
                on every entry of <em>value</em>. If <em>value</em> contains just one entry and the
                <code class="idlMemberName"><a href="#widl-JsonLdOptions-compactArrays">compactArrays</a></code> option is set to
                <code>true</code>, <em>value</em> is set to that entry.</li>
              <li>Add <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the compacted <em>value</em> to <em>output</em>.</li>
            </ol>
          </li>
          <li>Otherwise, <em>value</em> <em class="rfc2119" title="must">must</em> be an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
          <li>If <em>value</em> is empty:
            <ol class="algorithm">
              <li>Set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the result of performing
                <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a> on <em>property</em>.</li>
              <li>Create an entry in <em>output</em> for <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <em>value</em>.</li>
            </ol>
          </li>
          <li>For each <em>item</em> in <em>value</em>:
            <ol class="algorithm">
              <li>Set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the result of performing <a href="#iri-compaction"><abbr title="Internationalized Resource Identifier">IRI</abbr> Compaction</a>
                for <em>property</em> and <em>item</em> using the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
              <li>Compact <em>item</em> by recursively performing this algorithm passing a copy of
                the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> and the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
              <li>If an entry already exists in <em>output</em> for <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, convert it
                to an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> if necessary, and append the compacted <em>value</em>.</li>
              <li>Otherwise, if the compacted <em>value</em> is not an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
                has a <code>@container</code> mapping to <code>@set</code> or if the
                <code class="idlMemberName"><a href="#widl-JsonLdOptions-compactArrays">compactArrays</a></code> option is set to
                <code>false</code>, convert <em>value</em> to an array.</li>
              <li>Create an entry in <em>output</em> for <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <em>value</em>.</li>
            </ol>
          </li>
        </ol>
      </li>
    </ol>
  </li>
  <li>Otherwise, return <em>element</em> as the compacted <em>element</em>.
    <div class="issue"><div class="issue-title"><span>Issue</span></div><div class="">Perhaps this should also call <a href="#value-compaction">Value Compaction</a> on
      native types and strings, which could consolidate potential transformation in one place.</div></div>
  </li>
</ol>

<p>If, after the algorithm outlined above is run, the resulting <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, put <em>element</em> into the
  <code>@graph</code> property of a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> and then set <em>element</em> to that <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.
  Finally, add a <code>@context</code> property to <em>element</em> and set it to the initially passed <em>context</em>.</p>

</section>

</section>

<section id="flattening">
<h3><span class="secno">4.9 </span>Flattening</h3>

<p>Flattening is the process of taking a JSON-LD document, <a href="#expansion">expanding</a>
  it, labeling all unlabeled nodes with a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifier, and returning
  an array of the <a class="tref internalDFN" title="node" href="#dfn-node">nodes</a> defined in the document.</p>

<p>For example, assume the following JSON-LD input document:</p>

<div class="example"><div class="example-title"><span>Example 18</span></div><pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;knows&quot;: &quot;http://xmlns.com/foaf/0.1/knows&quot;
  },
  &quot;@id&quot;: &quot;http://example.com/markus&quot;,
  &quot;name&quot;: &quot;Markus Lanthaler&quot;,
  &quot;knows&quot;: {
    &quot;name&quot;: &quot;Manu Sporny&quot;
  }
}</pre></div>

<p>Running the JSON-LD Flattening algorithm for the merged graph (<code>@merged</code>) against
  the JSON-LD input document provided above would result in the following output:</p>

<div class="example"><div class="example-title"><span>Example 19</span></div><pre class="example">[
  {
    &quot;@id&quot;: &quot;http://example.com/markus&quot;,
    &quot;http://xmlns.com/foaf/0.1/knows&quot;: [ { &quot;@id&quot;: &quot;_:t0&quot; } ],
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [ { &quot;@value&quot;: &quot;Markus Lanthaler&quot; } ]
  },
  {
    &quot;@id&quot;: &quot;_:t0&quot;,
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [ { &quot;@value&quot;: &quot;Manu Sporny&quot; } ]
  }
]</pre></div>

<section id="flattening-algorithm">
<h4><span class="secno">4.9.1 </span>Flattening Algorithm</h4>
<p>The algorithm takes two input variables, an <em>element</em> to flatten and the
  <em>graph</em> for which the <a class="tref internalDFN" title="node" href="#dfn-node">node</a> definitions should be returned. If <em>graph</em>
  is not set, it will default to <code>@merged</code> which represents the result of
  merging all graphs including the default graph (<code>@default</code>).</p>

<ol class="algorithm">
  <li>Expand <em>element</em> according the <a href="#expansion-algorithm">Expansion Algorithm</a>.</li>
  <li>Generate a <em>nodeMap</em> according the <a href="#node-map-generation">Node Map Generation Algorithm</a>.</li>
  <li>Initialize an empty array <em>result</em>.</li>
  <li>If <em>nodeMap</em> has no property <em>graph</em>, return <em>result</em>, otherwise set <em>definitions</em> to its value.</li>
  <li>Foreach <em>property</em> and <em>value</em> of of <em>definitions</em> ordered by <em>property</em>:
    <ol class="algorithm">
      <li>Add <em>value</em> to <em>result</em>.</li>
    </ol>
  </li>
  <li>Return <em>result</em>.</li>
</ol>

</section>

<section id="node-map-generation">
<h4><span class="secno">4.9.2 </span>Node Map Generation</h4>
<p>The Node Map Generation algorithm takes as input an expanded JSON-LD document and results in a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>
  <em>nodeMap</em> holding a flat representation of the graphs and <a class="tref internalDFN" title="node" href="#dfn-node">nodes</a> represented in the document. All <a class="tref internalDFN" title="node" href="#dfn-node">nodes</a> that are not
  uniquely identified by an <abbr title="Internationalized Resource Identifier">IRI</abbr> get assigned a (new) <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifier. The resulting <em>nodeMap</em>
  document will have a property for every graph in the document whose value is another object with a property for every
  <a class="tref internalDFN" title="node" href="#dfn-node">node</a> represented in the document. While the default graph is stored under the <code>@default</code> property and the merged graph
  under the <code>@merged</code> property, all other graphs are stored under their respective <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a>.</p>

<p>The algorithm takes as input the expanded JSON-LD document as <em>element</em>, the initially empty <em>nodeMap</em>,
  <code>@default</code> as <em>graph</em>, <a class="tref internalDFN" title="null" href="#dfn-null">null</a> as <em>list</em>, and <a class="tref internalDFN" title="null" href="#dfn-null">null</a> as <em>id</em>.</p>

<ol class="algorithm">
  <li>If <em>element</em> is an array, process each entry in <em>element</em> recursively, using this algorithm
    and return.</li>
  <li>If <em>element</em> is not a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> or if it has a <code>@value</code> property,
    then if <em>list</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, append <em>element</em> to <em>list</em> and return.</li>
  <li>If <em>id</em> is <a class="tref internalDFN" title="null" href="#dfn-null">null</a> and if the <code>@id</code>
    property exists and is an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>, set <em>id</em> to its value,
    otherwise set it to a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifier created by the
    <a href="#generate-blank-node-identifier">Generate Blank Node Identifier</a>
    algorithm.</li>
  <li>If <em>list</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, append a new <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> to <em>list</em> using
    <em>id</em> as the value for <code>@id</code>.</li>
  <li>Let <em>nodes</em> be the value in <em>nodeMap</em> where the key is <em>graph</em>; if no such
    value exists, insert a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> for the key <em>graph</em>. If <em>id</em> is not in
    <em>nodes</em>, create a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> <em>node</em> with <em>id</em> as the value
    for <code>@id</code>. Let <em>node</em> be the value of <em>id</em> in <em>nodes</em>.</li>
  <li>For each <em>property</em> that is not <code>@id</code> and each <em>value</em> in <em>element</em> ordered
    by <em>property</em>:
    <ol class="algorithm">
      <li>If <em>property</em> is <code>@graph</code>, recursively call this algorithm passing <em>value</em>
        for <em>element</em>, <em>nodeMap</em>, <a class="tref internalDFN" title="null" href="#dfn-null">null</a> for <em>list</em> and if <em>graph</em>
        is <code>@merged</code> use <em>graph</em>, otherwise use <em>id</em> for <em>graph</em> and then continue.</li>
      <li>If <em>property</em> is not <code>@type</code> and is a keyword, merge <code>property</code> and
        <code>value</code> into <code>node</code> and then continue.</li>
      <li>For each value <em>v</em> in the array <em>value</em>:
        <ol class="algorithm">
          <li>If <em>v</em> is a <a class="tref internalDFN" title="node_definition" href="#dfn-node_definition">node definition</a> or <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>:
            <ol class="algorithm">
              <li>If the property <code>@id</code> is not an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a> or it does not exist,
                map <em>v</em> to a <a href="#generate-blank-node-identifier">new blank node
                identifier</a> <em>name</em> to avoid collisions. If one does
                not already exist, add a <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> for
                <em>v</em> into <em>node</em> for <em>property</em>.</li>
              <li>Recursively call this algorithm passing <em>v</em> for <em>value</em>, <em>nodeMap</em>,
                <em>graph</em>, <a class="tref internalDFN" title="null" href="#dfn-null">null</a> for <em>list</em>, and <em>name</em> for <em>id</em>.</li>
            </ol>
          </li>
          <li>Otherwise if <em>v</em> has the property <code>@list</code> then recursively call this algorithm
            with the value of <code>@list</code> as <em>element</em>, <em>nodeMap</em>, <em>graph</em>, and
            a new array <em>flattenedList</em> as <em>list</em>. Create a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with the
            property <code>@list</code> set to <em>flattenedList</em> and add it to <em>node</em> for
            <em>property</em>.</li>
          <li>Otherwise, if <em>property</em> is <code>@type</code> and <em>v</em> is not an <a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></a>,
            generate a <a href="#generate-blank-node-identifier">new blank node identifier</a> and add it
            to <em>node</em> for <em>property</em>.</li>
          <li>Otherwise, add <em>v</em> to <em>node</em> for <em>property</em>.</li>
        </ol>
      </li>
    </ol>
  </li>
</ol>

<p>After the above outlined algorithm has been executed, the node map for all graphs including the default graph are contained in
  <em>nodeMap</em>. To also create the node map for the merged graph, execute the algorithm again, but pass <code>@merged</code>
  for <em>graph</em>.</p>

</section>

<section id="generate-blank-node-identifier">
<h4><span class="secno">4.9.3 </span>Generate Blank Node Identifier</h4>
<p>This algorithm is used by the <a href="#node-map-generation">Node Map Generation Algorithm</a> to
  deterministically name <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identifiers. It uses a <em>identifier map</em>
  and <em>prefix</em> and takes a possibly <a class="tref internalDFN" title="null" href="#dfn-null">null</a> identifier and returns a new identifier based
  on <em>prefix</em>.</p>
<p>The variable <em>next identifier</em> is initialized to <em>prefix</em> appended with <code>0</code>. The
  default value of <em>prefix</em> is <code>_:t</code>.</p>

<ol class="algorithm">
  <li>If the old identifier is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a> and is in the <em>identifier map</em>,
    return the mapped identifier.</li>
  <li>Otherwise, if the old identifier is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, create a new entry in
    <em>identifier map</em> initialized to the current value of <em>next identifier</em>. Increment
    <em>next identifier</em> by adding one to the integer suffix. Return the mapped identifier.</li>
  <li>Otherwise, increment <em>next identifier</em> by adding one to the integer suffix and return its
    original value.</li>
</ol>
</section>

</section>

<section id="rdf-conversion-1">
<h3><span class="secno">4.10 </span>RDF Conversion</h3>

<p>A JSON-LD document <em class="rfc2119" title="may">may</em> be converted between other RDF-compatible document
  formats using the algorithms specified in this section.</p>

<p>The JSON-LD Processing Model describes processing rules for extracting RDF
  from a JSON-LD document, and for transforming an array of <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> retrieved by processing
  another serialization format into JSON-LD. Note that many uses of JSON-LD may not require
  generation of RDF.</p>

<p>The processing algorithms described in this section are provided in
  order to demonstrate how one might implement a JSON-LD to RDF processor.
  Conformant implementations are only required to produce the same type and
  number of quads during the output process and are not required to
  implement the algorithm exactly as described.</p>

<section class="informative" id="overview">
  <h4><span class="secno">4.10.1 </span>Overview</h4><p><em>This section is non-normative.</em></p>
  <p>
    JSON-LD is intended to have an easy to parse grammar that closely models existing
    practice in using JSON for describing object representations. This allows the use
    of existing libraries for parsing JSON.
  </p>
  <p>
    As with other grammars used for describing <a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">Linked Data</a>, a key
    concept is that of a <a class="tref internalDFN" title="node" href="#dfn-node">node</a> in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.
    Nodes may be of three basic types.
    The first is the <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>, which is used to refer to
    <a class="tref internalDFN" title="node" href="#dfn-node">node</a>s in other <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>s.
    The second is the
    <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>, which are nodes for which an external name does not
    exist, or is not known. The third is a <a class="tref internalDFN" title="literal" href="#dfn-literal">Literal</a>, which express
    values such as strings, dates and other information having a lexical
    form, possibly including an explicit language or datatype.
  </p>
  <p>Data described with JSON-LD may be considered to be a graph made
    up of <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> and <a class="tref internalDFN" title="object" href="#dfn-object">object</a>
    <a class="tref internalDFN" title="node" href="#dfn-node">nodes</a> related via a <a class="tref internalDFN" title="property" href="#dfn-property">property</a>
    <a class="tref internalDFN" title="node" href="#dfn-node">node</a>. Specific implementations may also choose to operate
    on the document as a normal JSON description of objects having
    attributes. Both approaches are valid ways to interact with JSON-LD
    documents.</p>
</section>

<section class="informative" id="parsing-examples">
  <h4><span class="secno">4.10.2 </span>Parsing Examples</h4><p><em>This section is non-normative.</em></p>

  <p>The following examples show simple transformations of JSON-LD documents to Turtle [<cite><a class="bibref" href="#bib-TURTLE-TR">TURTLE-TR</a></cite>].</p>

  <p>The first example uses a simple document containing a simple FOAF profile:</p>

<div class="example"><div class="example-title"><span>Example 20</span></div><pre class="example">{
  &quot;@context&quot;: {&quot;foaf&quot;: &quot;http://xmlns.com/foaf/0.1/&quot;},
  &quot;@id&quot;: &quot;http://greggkellogg.net/foaf#me&quot;,
  &quot;@type&quot;: &quot;foaf:Person&quot;,
  &quot;foaf:name&quot;: &quot;Gregg Kellogg&quot;,
  &quot;foaf:knows&quot;: {
    &quot;@type&quot;: &quot;foaf:Person&quot;,
    &quot;foaf:name&quot;: &quot;Manu Sporny&quot;
  }
}</pre></div>

  <p>This translates fairly directly to a similar Turtle document:</p>

<div class="example"><div class="example-title"><span>Example 21</span></div><pre class="example">@prefix foaf: &lt;http://xmlns.com/foaf/0.1/&gt;.

&lt;http://greggkellogg.net/foaf#me&gt; a foaf:Person;
  foaf:name &quot;Gregg Kellogg&quot;;
  foaf:knows [ a foaf:Person; foaf:name &quot;Manu Sporny&quot;].</pre></div>

  <p>The actual parsing steps first require that the JSON-LD document be expanded,
    to eliminate the <code>@context</code>:</p>

<div class="example"><div class="example-title"><span>Example 22</span></div><pre class="example">[{
  &quot;@id&quot;: &quot;http://greggkellogg.net/foaf#me&quot;,
  &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Gregg Kellogg&quot;}],
  &quot;http://xmlns.com/foaf/0.1/knows&quot;: [{
    &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Manu Sporny&quot;}]
  }]
}]</pre></div>

  <p>The process of translating this to RDF then operates over each
    <a class="tref internalDFN" title="node_definition" href="#dfn-node_definition">node definition</a> to find a subject,
    each <a class="tref internalDFN" title="property" href="#dfn-property">property</a> to find an <a class="tref internalDFN" title="rdf_predicate" href="#dfn-rdf_predicate">RDF predicate</a>,
    and each value of that property to find an <a class="tref internalDFN" title="object" href="#dfn-object">object</a>.
    In this case, each property has just a single object:
    <code>foaf:name</code> identifies a <a class="tref internalDFN" title="literal" href="#dfn-literal">literal</a>, and
    <code>foaf:knows</code> identifies a second <a class="tref internalDFN" title="node_definition" href="#dfn-node_definition">node definition</a>
    similar to Turtle's <code>blankNodePropertyList</code>.</p>

  <p>After expansion, JSON-LD <a class="tref internalDFN" title="number" href="#dfn-number">numbers</a>,
    <a class="tref internalDFN" title="true" href="#dfn-true">booleans</a>, <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literals</a>,
    <a class="tref internalDFN" title="language-tagged_string" href="#dfn-language-tagged_string">language-tagged-strings</a>,
    and <a class="tref internalDFN" title="iri" href="#dfn-iri">IRIs</a> become explicit, and can be directly
    transformed into their RDF representations.</p>

<div class="example"><div class="example-title"><span>Example 23</span></div><pre class="example">[{
  &quot;@id&quot;: &quot;http://greggkellogg.net/foaf#me&quot;,
  &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Gregg Kellogg&quot;}],
  <span class="diff">&quot;http://xmlns.com/foaf/0.1/currentProject&quot;: [{&quot;@id&quot;: &quot;http://json-ld.org/&quot;}],
  &quot;http://xmlns.com/foaf/0.1/birthday&quot;: [{
    &quot;@value&quot;: &quot;1957-02-27&quot;,
    &quot;@type&quot;: &quot;http://www.w3.org/2001/XMLSchema#date&quot;
  }],</span>
  &quot;http://xmlns.com/foaf/0.1/knows&quot;: [{
    &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Manu Sporny&quot;}]
  }]
}]</pre></div>

  <p>Translates to:</p>

<div class="example"><div class="example-title"><span>Example 24</span></div><pre class="example">@prefix foaf: &lt;http://xmlns.com/foaf/0.1/&gt;.
@prefix xsd: &lt;http://www.w3.org/2001/XMLSchema#&gt;.

&lt;http://greggkellogg.net/foaf#me&gt; a foaf:Person;
  foaf:name &quot;Gregg Kellogg&quot;;
  <span class="diff">foaf:currentProject &lt;http://json-ld.org/&gt;;
  foaf:birthday &quot;1957-02-27&quot;^^xsd:date;</span>
  foaf:knows [ a foaf:Person; foaf:name &quot;Manu Sporny&quot;].</pre></div>

</section>

<section id="convert-to-rdf-algorithm">
  <h4><span class="secno">4.10.3 </span>Convert to RDF Algorithm</h4>
  <p>
    The algorithm below is designed for in-memory implementations with random access to <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> elements.
  </p>
  <p>
    A conforming JSON-LD processor implementing RDF conversion <em class="rfc2119" title="must">must</em> implement a
    processing algorithm that results in the same set of RDF <a class="tref internalDFN" title="quad" href="#dfn-quad">Quads</a> that the following
    algorithm generates:
  </p>

  <p>The algorithm takes four input variables: a <em>element</em> to be converted, an
    <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.
    To begin, the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>
    are set to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and <em>element</em> is
    set to the result of performing the <a href="#expansion-algorithm">Expansion Algorithm</a> on
    the <a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">JSON-LD input</a>. This removes any existing context to allow the given context to be cleanly
    applied.</p>

  <ol class="algorithm">
    <li id="processing-step-associative">
      If <em>element</em> is a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>, perform the following steps:
      <ol class="algorithm">
        <li>Set <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to <a class="tref internalDFN" title="null" href="#dfn-null">null</a>.</li>
        <li>
          If <em>element</em> has a <code>@value</code> property:
          <ol class="algorithm">
            <li>If the value of <code>@value</code> is a <a class="tref internalDFN" title="number" href="#dfn-number">number</a>, set the
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> using a string representation
              of the value as defined in the section <a href="#data-round-tripping">Data Round Tripping</a>.
              Set datatype to the value of the <code>@type</code> property if it exists, otherwise
              either <code>xsd:integer</code> or <code>xsd:double</code>, depending
              on if the value contains a fractional and/or an exponential component.</li>
            <li>Otherwise, if the value of <code>@value</code> is <strong>true</strong> or <strong>false</strong>,
              set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> created from the
              string representation of the value. Set datatype to the value of the <code>@type</code>
              property if it exists, otherwise <code>xsd:boolean</code>.</li>
            <li>
              Otherwise, if <em>element</em> contains a <code>@type</code> property, set the
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>.
            </li>
            <li>
              Otherwise, if <em>element</em> contains a <code>@language</code> property, set the
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="language-tagged_string" href="#dfn-language-tagged_string">language-tagged string</a>.
            </li>
            <li>
              Otherwise, set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>
              using <code>xsd:string</code> as the datatype.
            </li>
          </ol>
        </li>
        <li>
          If <em>element</em> has a <code>@list</code> property the value <em class="rfc2119" title="must">must</em> be an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.
          Process its value as a list as described in <a href="#list-conversion">List Conversion</a> using
          the return value as the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>
        </li>
        <li>If <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>:
          <ol class="algorithm">
            <li>If neither <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> nor <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> are <a class="tref internalDFN" title="null" href="#dfn-null">null</a>,
              generate a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>
              representing <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>,
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>, and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.</li>
            <li>Return <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>.</li>
          </ol>
        </li>
        <li id="processing-step-subject">If <em>element</em> has a <code>@id</code> property,
          the value <em class="rfc2119" title="must">must</em> be a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, set the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> to the previously
          expanded value (either a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> or an <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>).</li>
        <li>
          Otherwise, if <em>element</em> does not have a <code>@id</code> property, set the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active
          subject</a> to newly generated <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>.</li>
        <li>
          Process each <em>property</em> and <em>value</em> in <em>element</em>, ordered by
          <em>property</em>, as follows:
          <ol class="algorithm">
            <li>
              If <em>property</em> is <code>@type</code>, set the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
              to <code>rdf:type</code>.
            </li>
            <li>Otherwise, if <em>property</em> is <code>@graph</code>,
              process <em>value</em> algorithm recursively, using <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> as <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>
              and null values for <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and then
              proceed to next property.</li>
            <li>Otherwise, if <em>property</em> is a <a class="tref internalDFN" title="keyword" href="#dfn-keyword">keyword</a>, skip this step.</li>
            <li>Otherwise, set <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the <abbr title="Internationalized Resource Identifier">IRI</abbr> value of <em>property</em>.</li>
            <li>Process <em>value</em> recursively using this algorithm, passing copies of
              <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.
            </li>
          </ol>
        </li>
        <li>
          Set <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>.
        </li>
      </ol>
    </li>

    <li>Otherwise, if <em>element</em> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each value in the <a class="tref internalDFN" title="array" href="#dfn-array">array</a>
      as follows, process <em>element</em> recursively using this algorithm, using copies of
      <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, and <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.</li>

    <li>Otherwise, if <em>element</em> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, then the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
      must be <code>rdf:type</code> so set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to an <a class="datatype idlType" title="IRI" href="#idl-def-IRI"><code><abbr title="Internationalized Resource Identifier">IRI</abbr></code></a>.</li>

    <li>If any of these steps created an <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> and neither <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>
      nor <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> are <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, generate a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> using
      <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>,<a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>, <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> and
      <a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">graph name</a>.
    </li>
    <li>Return <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>.</li>
  </ol>
</section>
<section id="list-conversion">
  <h4><span class="secno">4.10.4 </span>List Conversion</h4>

  <p>List Conversion is the process of taking an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> of values and adding them to a newly
    created <cite><a href="http://www.w3.org/TR/rdf-schema/#ch_collectionvocab">RDF Collection</a></cite> (see
    [<cite><a class="bibref" href="#bib-RDF-SCHEMA">RDF-SCHEMA</a></cite>]) by linking each element of the list using <code>rdf:first</code> and <code>rdf:next</code>,
    terminating the list with <code>rdf:nil</code> using the following sequence:</p>
  <p>The algorithm is invoked with an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> <em>array</em>, the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
    and returns a value to be used as an <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> in the calling location.</p>
  <div class="note"><div class="note-title"><span>Note</span></div><div class="">This algorithm does not support lists containing lists.</div></div>
  <ol class="algorithm">
    <li>
      If <em>array</em> is empty return <code>rdf:nil</code>.
    </li>
    <li>
      Otherwise, generate a <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> using using the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
      and a newly generated <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identified as <em>first <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a></em>.
    </li>
    <li>
      For each element in <em>array</em> other than the last element:
      <ol class="algorithm">
        <li>Create a processor state using
          <em>first blank node</em> as the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, and
          <code>rdf:first</code> as the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
          <ol class="algorithm">
            <li>Process the value starting at <a href="#processing-step-associative">Step 1</a>.</li>
            <li>Proceed using the previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.</li>
          </ol>
        </li>
        <li>Unless this is the last element in <em>array</em>, generate a new <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a> identified as
          <em>rest blank node</em>, otherwise use <code>rdf:nil</code>.</li>
        <li>Generate a new <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> using <em>first blank node</em>,
          <code>rdf:rest</code> and <em>rest blank node</em>.</li>
        <li>Set <em>first blank node</em> to
          <em>rest blank node</em>.</li>
        <li>Return <em>first blank node</em>.</li>
      </ol>
    </li>
  </ol>
</section>

<section id="convert-from-rdf-algorithm">
  <h4><span class="secno">4.10.5 </span>Convert from RDF Algorithm</h4>
  <p>In some cases, data exists natively in Triples or Quads form; for example, if the data was originally
    represented in an RDF graph or triple/quad store. This algorithm is designed to simply translate
    an array of <a class="datatype idlType" title="Quad" href="#idl-def-Quad"><code>Quads</code></a> into a JSON-LD document.</p>
  <p>When expanding <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> values having a datatype of <code>xsd:string</code>,
    the <code>@type</code> <em class="rfc2119" title="must not">must not</em> be set to <code>xsd:string</code> and the resulting value
    <em class="rfc2119" title="must">must</em> have only a <code>@value</code> property.</p>

  <p>The conversion algorithm takes a single parameter <em>input</em> in the form of an
    array of <a href="#idl-def-Quad" class="idlType"><code>Quad</code></a> representations.</p>

  <ol class="algorithm">
    <li id="new_graph">Construct <em>defaultGraph</em> as a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>
      containing <em>nodes</em> and <em>listMap</em>, each an empty <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a>.</li>
    <li>Construct <em>graphs</em> as a <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> containing <em>defaultGraph</em>
      identified by
      an empty <a class="tref internalDFN" title="string" href="#dfn-string">string</a>.</li>
    <li>For each quad in <em>input</em>:
      <ol class="algorithm">
        <li>Set <em>graph</em> to the entry in <em>graphs</em> identified
          by <em>name</em>, initializing it to a new entry using the mechanism
          described in <a href="#new_graph">Step 1</a>.</li>
        <li>If <em>property</em> is <code>rdf:first</code>,
          use the entry in <em>graph.listMap</em> indexed by <em>subject</em>,
          initializing it to a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> if nesessary. Represent
          <em>object</em> in expanded form, as described in
          <a href="#value-expansion">Value Expansion</a>. Add the
          resulting <em>object representation</em> to the entry indexed by
          <em>first</em>, and skip to the next quad.</li>
        <li>If <em>property</em> is <code>rdf:rest</code>:
          <ol class="algorithm">
            <li>If <em>object</em> is a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>, use the entry in
              <em>graph.listMap</em> indexed by <em>subject</em>, initializing it
              to a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> if necessary. Add the <em>nominalValue</em> of
              <em>object</em> to the entry indexed by <em>rest</em>.
            </li>
            <li>Skip to the next quad.</li>
          </ol>
        </li>
        <li>If <em>name</em> is not <a class="tref internalDFN" title="null" href="#dfn-null">null</a>, and <em>defaultGraph.nodes</em>
          does not contain an entry for <em>name</em>,
          create a new entry for <em>name</em> from a new
          <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with key/value pair of <code>@id</code> and
          a string representation of <em>name</em>.</li>
        <li>Set <em>value</em> as the entry from <em>graph.nodes</em> for
          <em>subject</em>, initializing it to a new
          <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> with key/value pair of <code>@id</code> and
          a string representation of <em>subject</em> if necessary.</li>
        <li>If <em>property</em> is <code>rdf:type</code> and the
          <code class="idlMemberName"><a href="#widl-JsonLdOptions-useRdfType">useRdfType</a></code>
          option is not present or <a class="tref internalDFN" title="false" href="#dfn-false">false</a>:
          <ol class="algorithm">
            <li>Append the string representation of <em>object</em> to the array value for the
              key <code>@type</code>, creating an entry in <em>value</em> if necessary.</li>
          </ol>
        </li>

        <li>If <em>object</em> is a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> and the
          <code class="idlMemberName"><a href="#widl-JsonLdOptions-useNativeTypes">useNativeTypes</a></code>
          option is set to <a class="tref internalDFN" title="true" href="#dfn-true">true</a>:
          <ol class="algorithm">
            <li>Generate a <em>converted value</em>:
              <ol class="algorithm">
                <li>If the literal's type is <code>xsd:boolean</code>, the
                  <em>converted value</em> is <a class="tref internalDFN" title="true" href="#dfn-true">true</a> if the literal
                  matches the value <code>true</code> or <a class="tref internalDFN" title="false" href="#dfn-false">false</a> if
                  the literal matches the value <code>false</code>.</li>
                <li>If the literal's type is <code>xsd:integer</code> or
                  <code>xsd:double</code>, try to convert the literal to a
                  JSON <a class="tref internalDFN" title="number" href="#dfn-number">number</a>. If the conversion is successful,
                  store the result in <em>converted value</em>, otherwise
                  set <em>converted value</em> to <em>value</em>.</li>
                <li>Otherwise, do not perform a conversion. Set
                  the <em>converted value</em> to the <em>value</em>.</li>
              </ol>
            </li>
            <li>Append the <em>converted value</em> to the array value for the
              key, creating an entry in <em>value</em> if necessary.</li>
          </ol>
        </li>

        <li>Otherwise, if <em>object</em> is <code>rdf:nil</code>:
          <ol class="algorithm">
            <li>Let <em>key</em> be the string representation of <em>property</em>.</li>
            <li>Append an empty <code>@list</code> representation to the array value for
              <em>key</em>, creating an entry in <em>value</em> if necessary.</li>
          </ol>
        </li>
        <li>Otherwise,
          <ol class="algorithm">
            <li>Let <em>key</em> be the string representation of <em>property</em> and let
              <em>object representation</em>
              be <em>object</em> represented in expanded form as described in
              <a href="#value-expansion">Value Expansion</a>.</li>
            <li>If <em>object</em> is a <a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">blank node</a>,
              use the entry in <em>graph.listMap</em> indexed by <em>object</em>,
              initializing it to a new <a class="tref internalDFN" title="json_object" href="#dfn-json_object">JSON object</a> if nesessary.
              Add an entry for <em>head</em> with <em>object representation</em>.</li>
            <li>Append <em>object representation</em> to the array value for
              <em>key</em>, creating an entry in <em>value</em> if necessary.</li>
          </ol>
        </li>
      </ol>
    </li>
    <li>For each <em>name</em> and <em>graph</em> in <em>graphs</em>:
      <ol class="algorithm">
        <li>For each <em>subject</em> and <em>entry</em> in <em>graph</em>
          where <em>entry</em> has both <em>head</em> and <em>first</em> keys:
          <ol class="algorithm">
            <li>Set <em>value</em> to the value of <em>head</em> in <em>entry</em>.</li>
            <li>Remove the entry for <code>@id</code> in <em>value</em>.</li>
            <li>Add an entry to <em>value</em> for <code>@list</code> initialized to a new array
              containing the value of <em>first</em> from <em>entry</em>.</li>
            <li>While <em>entry</em> has a key for <em>rest</em>:
              <ol class="algorithm">
                <li>Set <em>entry</em> to the value of <em>graph.listMap</em> for <em>entry.rest</em>.</li>
                <li>Add the value for <em>entry.first</em> to the list array.</li>
              </ol>
            </li>
          </ol>
        </li>
      </ol>
    </li>
    <li>Create <em>array</em> as an empty <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</li>
    <li>For each <em>subject</em> and <em>entry</em> in <em>defaultGraph.nodes</em>
      ordered by <em>subject</em>:
      <ol class="algorithm">
        <li>Add <em>entry</em> to <em>array</em>.</li>
        <li>If <em>graphs</em> has an entry for <em>subject</em>, add a property
          <code>@graph</code> in <em>entry</em> containing the ordered entries
          from <em>graphs[subject].nodes</em>.</li>
      </ol>
    </li>
    <li>Return <em>array</em> as the result.</li>
  </ol>
</section>
</section>

</section>

<section id="data-round-tripping">

<!--OddPage-->
<h2><span class="secno">5. </span>Data Round Tripping</h2>

<p>When <a href="#rdf-conversion">converting JSON-LD to RDF</a> JSON-native types such as
  <em>numbers</em> and <em>booleans</em> are automatically coerced to <strong>xsd:integer</strong>,
  <strong>xsd:double</strong>, or <strong>xsd:boolean</strong>. Implementers <em class="rfc2119" title="must">must</em> ensure that the
  result is a canonical lexical form in the form of a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>. A
  <dfn title="canonical_lexical_form" id="dfn-canonical_lexical_form">canonical lexical form</dfn> is a set of literals from among the valid set of literals for
  a datatype such that there is a one-to-one mapping between the canonical lexical form and a value
  in the value space as defined in [<cite><a class="bibref" href="#bib-XMLSCHEMA11-2">XMLSCHEMA11-2</a></cite>]. In other words, every value <em class="rfc2119" title="must">must</em> be converted
  to a deterministic string representation.</p>

<p>The canonical lexical form of an <em>integer</em>, i.e., a number without fractions
  or a number coerced to <strong>xsd:integer</strong>, is a finite-length sequence of decimal
  digits (<code>0-9</code>) with an optional leading minus sign; leading zeroes are prohibited.
  To convert the number in JavaScript, implementers can use the following snippet of code:</p>

<div class="example"><div class="example-title"><span>Example 25</span></div><pre class="example">(value).toFixed(0).toString()</pre></div>

<p>The canonical lexical form of a <em>double</em>, i.e., a number with fractions
  or a number coerced to <strong>xsd:double</strong>, consists of a mantissa followed by the
  character &quot;E&quot;, followed by an exponent. The mantissa <em class="rfc2119" title="must">must</em> be a decimal number. The exponent
  <em class="rfc2119" title="must">must</em> be an integer. Leading zeroes and a preceding plus sign (<code>+</code>) are prohibited
  in the exponent. If the exponent is zero, it must be indicated by <code>E0</code>.
  For the mantissa, the preceding optional plus sign is prohibited and the decimal point is
  required. Leading and trailing zeroes are prohibited subject to the following: number
  representations must be normalized such that there is a single digit which is non-zero to the
  left of the decimal point and at least a single digit to the right of the decimal point unless
  the value being represented is zero. The canonical representation for zero is <code>0.0E0</code>.
  <strong>xsd:double</strong>'s value space is defined by the IEEE double-precision 64-bit
  floating point type [<cite><a class="bibref" href="#bib-IEEE-754-1985">IEEE-754-1985</a></cite>]; in JSON-LD the mantissa is rounded to 15 digits after the
  decimal point.</p>

<p>To convert the number in JavaScript, implementers can use the following snippet of code:</p>

<div class="example"><div class="example-title"><span>Example 26</span></div><pre class="example">(value).toExponential(15).replace(/(\d)0*e\+?/,'$1E')</pre></div>

<div class="note"><div class="note-title"><span>Note</span></div><p class="">When data such as decimals need to be normalized, JSON-LD authors should
  not use values that are going to undergo automatic conversion. This is due to the lossy nature
  of <strong>xsd:double</strong> values. Authors should instead use the expanded object form to
  set the canonical lexical form directly.</p></div>

<p>The canonical lexical form of the <em>boolean</em> values <code>true</code> and <code>false</code>
  are the strings <strong>true</strong> and <strong>false</strong>.</p>

<p>When JSON-native <a class="tref internalDFN" title="number" href="#dfn-number">number</a>s, are type coerced, lossless data round-tripping can not
  be guaranted as rounding errors might occur. Additionally, only literals typed as
  <strong>xsd:integer</strong>, <strong>xsd:double</strong>, and  <strong>xsd:boolean</strong> are
  automatically converted back to their JSON-native counterparts in when
  <a href="#rdf-conversion">converting from RDF</a>.</p>

<div class="note"><div class="note-title"><span>Note</span></div><p class="">Some JSON serializers, such as PHP's native implementation in some versions,
  backslash-escape the forward slash character. For example, the value
  <code>http://example.com/</code> would be serialized as <code>http:\/\/example.com\/</code>.
  This is problematic as other JSON parsers might not understand those escaping characters.
  There is no need to backslash-escape forward slashes in JSON-LD. To aid interoperability
  between JSON-LD processors, a JSON-LD serializer <em class="rfc2119" title="must not">must not</em> backslash-escape forward slashes.</p></div>

</section>

<section class="appendix" id="acknowledgements">

<!--OddPage-->
<h2><span class="secno">A. </span>Acknowledgements</h2>

<p>A large amount of thanks goes out to the JSON-LD Community Group
participants who worked through many of the technical issues on the mailing
list and the weekly telecons - of special mention are Niklas Lindström,
François Daoust, and Zdenko 'Denny' Vrandečić.
The editors would like to thank Mark Birbeck, who provided a great deal of
the initial push behind the JSON-LD work via his work on RDFj.
The work of Dave Lehn and Mike Johnson are appreciated for reviewing,
and performing several implementations of the specification. Ian Davis is
thanked for this work on RDF/JSON. Thanks also to Nathan Rixham,
Bradley P. Allen,
Kingsley Idehen, Glenn McDonald, Alexandre Passant, Danny Ayers, Ted
Thibodeau Jr., Olivier Grisel, Josh Mandel, Eric Prud'hommeaux,
David Wood, Guus Schreiber, Pat Hayes, Sandro Hawke, and Richard
Cyganiak for their input on the specification.
</p></section>



<section id="references" class="appendix">
<!--OddPage-->
<h2><span class="secno">B. </span>References</h2><section id="normative-references"><h3><span class="secno">B.1 </span>Normative references</h3><dl class="bibliography"><dt id="bib-BCP47">[BCP47]</dt><dd>A. Phillips; M. Davis. <a href="http://tools.ietf.org/html/bcp47"><cite>Tags for Identifying Languages</cite></a> September 2009. IETF Best Current Practice. URL: <a href="http://tools.ietf.org/html/bcp47">http://tools.ietf.org/html/bcp47</a> 
</dd><dt id="bib-IEEE-754-1985">[IEEE-754-1985]</dt><dd>IEEE. <cite>IEEE Standard for Binary Floating-Point Arithmetic.</cite> See <a href="http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html">http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html</a>
</dd><dt id="bib-JSON-LD">[JSON-LD]</dt><dd><cite><a href="http://json-ld.org/spec/ED/json-ld-syntax/20120522/">The JSON-LD Syntax</a></cite> Manu Sporny, Gregg Kellogg, Markus Lanthaler Editors. World Wide Web Consortium (work in progress). 22 May 2012. Editor's Draft. This edition of the JSON-LD Syntax specification is http://json-ld.org/spec/ED/json-ld-syntax/20120522/. The <a href="http://json-ld.org/spec/latest/json-ld-syntax/">latest edition of the JSON-LD Syntax</a> is available at http://json-ld.org/spec/latest/json-ld-syntax/
</dd><dt id="bib-JSON-POINTER">[JSON-POINTER]</dt><dd><cite><a href="http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-02">JSON Pointer</a></cite> P. Bryan, Ed. IETF Draft. URL: <a href="http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-02">http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-02</a>
</dd><dt id="bib-RDF-CONCEPTS">[RDF-CONCEPTS]</dt><dd><cite><a href="http://www.w3.org/TR/2011/WD-rdf11-concepts-20110830/">RDF 1.1 Concepts and Abstract Syntax</a></cite> Richard Cyganiak, David Wood, Editors. World Wide Web Consortium (work in progress). 30 May 2012. Editor's Draft. This edition of the JSON-LD Syntax specification is http://www.w3.org/TR/2011/WD-rdf11-concepts-20110830/. The <a href="http://www.w3.org/TR/rdf11-concepts/">latest edition of the JSON-LD Syntax</a> is available at http://www.w3.org/TR/rdf11-concepts/
</dd><dt id="bib-RDF-SCHEMA">[RDF-SCHEMA]</dt><dd>Dan Brickley; Ramanathan V. Guha. <a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><cite>RDF Vocabulary Description Language 1.0: RDF Schema.</cite></a> 10 February 2004. W3C Recommendation. URL: <a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210">http://www.w3.org/TR/2004/REC-rdf-schema-20040210</a> 
</dd><dt id="bib-RFC3986">[RFC3986]</dt><dd>T. Berners-Lee; R. Fielding; L. Masinter. <a href="http://www.ietf.org/rfc/rfc3986.txt"><cite>Uniform Resource Identifier (URI): Generic Syntax.</cite></a> January 2005. Internet RFC 3986. URL: <a href="http://www.ietf.org/rfc/rfc3986.txt">http://www.ietf.org/rfc/rfc3986.txt</a> 
</dd><dt id="bib-RFC3987">[RFC3987]</dt><dd>M. Dürst; M. Suignard. <a href="http://www.ietf.org/rfc/rfc3987.txt"><cite>Internationalized Resource Identifiers (IRIs).</cite></a> January 2005. Internet RFC 3987. URL: <a href="http://www.ietf.org/rfc/rfc3987.txt">http://www.ietf.org/rfc/rfc3987.txt</a> 
</dd><dt id="bib-RFC4627">[RFC4627]</dt><dd>D. Crockford. <a href="http://www.ietf.org/rfc/rfc4627.txt"><cite>The application/json Media Type for JavaScript Object Notation (JSON)</cite></a> July 2006. Internet RFC 4627. URL: <a href="http://www.ietf.org/rfc/rfc4627.txt">http://www.ietf.org/rfc/rfc4627.txt</a>
</dd><dt id="bib-WEBIDL">[WEBIDL]</dt><dd><cite><a href="http://www.w3.org/TR/2012/CR-WebIDL-20120419/">Web IDL</a></cite> Cameron McCormack, Editor. World Wide Web Consortium. 19 April 2012. Candidate Recommendataion. This edition of Web IDL is http://www.w3.org/TR/2012/CR-WebIDL-20120419/. The <a href="http://dev.w3.org/2006/webapi/WebIDL/">latest edition of Web IDL</a> is available at http://dev.w3.org/2006/webapi/WebIDL/
</dd><dt id="bib-XMLSCHEMA11-2">[XMLSCHEMA11-2]</dt><dd>Henry S. Thompson; et al. <a href="http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/"><cite>W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes.</cite></a> 5 April 2012. W3C Recommendation URL: <a href="http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/">http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/</a> 
</dd></dl></section><section id="informative-references"><h3><span class="secno">B.2 </span>Informative references</h3><dl class="bibliography"><dt id="bib-ECMA-262">[ECMA-262]</dt><dd><a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm"><cite>ECMAScript Language Specification.</cite></a> June 2011. URL: <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">http://www.ecma-international.org/publications/standards/Ecma-262.htm</a> 
</dd><dt id="bib-TURTLE-TR">[TURTLE-TR]</dt><dd>Eric Prud'hommeaux, Gavin Carothers. <cite><a href="http://www.w3.org/TR/2011/WD-turtle-20110809/">Turtle: Terse RDF Triple Language.</a></cite> 09 August 2011. W3C Working Draft. URL: <a href="http://www.w3.org/TR/2011/WD-turtle-20110809/">http://www.w3.org/TR/2011/WD-turtle-20110809/</a>
</dd><dt id="bib-UNICODE">[UNICODE]</dt><dd>The Unicode Consortium. <a href="http://www.unicode.org/unicode/standard/versions/enumeratedversions.html"><cite>The Unicode Standard.</cite></a> 2003. Defined by: The Unicode Standard, Version 4.0 (Boston, MA, Addison-Wesley, ISBN 0-321-18578-1), as updated from time to time by the publication of new versions URL: <a href="http://www.unicode.org/unicode/standard/versions/enumeratedversions.html">http://www.unicode.org/unicode/standard/versions/enumeratedversions.html</a> 
</dd></dl></section></section></body></html>
